export declare const exitSchema: <A, I, E, EI, R>(
  self: WithResult<A, I, E, EI, R>
) => Schema.Schema<Exit.Exit<A, E>, Schema.ExitEncoded<I, EI>, R>

export declare const failureSchema: <A, I, E, EI, R>(self: WithResult<A, I, E, EI, R>) => Schema.Schema<E, EI, R>

export declare const selfSchema: <A, I, R>(self: Serializable<A, I, R>) => Schema.Schema<A, I, R>

export declare const successSchema: <A, I, E, EI, R>(self: WithResult<A, I, E, EI, R>) => Schema.Schema<A, I, R>

export declare const deserialize: {
  (value: unknown): <A, I, R>(self: Serializable<A, I, R>) => Effect.Effect<A, ParseResult.ParseError, R>
  <A, I, R>(self: Serializable<A, I, R>, value: unknown): Effect.Effect<A, ParseResult.ParseError, R>
}

export declare const deserializeExit: {
  (
    value: unknown
  ): <A, I, E, EI, R>(self: WithResult<A, I, E, EI, R>) => Effect.Effect<Exit.Exit<A, E>, ParseResult.ParseError, R>
  <A, I, E, EI, R>(
    self: WithResult<A, I, E, EI, R>,
    value: unknown
  ): Effect.Effect<Exit.Exit<A, E>, ParseResult.ParseError, R>
}

export declare const deserializeFailure: {
  (value: unknown): <A, I, E, EI, R>(self: WithResult<A, I, E, EI, R>) => Effect.Effect<E, ParseResult.ParseError, R>
  <A, I, E, EI, R>(self: WithResult<A, I, E, EI, R>, value: unknown): Effect.Effect<E, ParseResult.ParseError, R>
}

export declare const deserializeSuccess: {
  (value: unknown): <A, I, E, EI, R>(self: WithResult<A, I, E, EI, R>) => Effect.Effect<A, ParseResult.ParseError, R>
  <A, I, E, EI, R>(self: WithResult<A, I, E, EI, R>, value: unknown): Effect.Effect<A, ParseResult.ParseError, R>
}

export declare const serialize: <A, I, R>(self: Serializable<A, I, R>) => Effect.Effect<I, ParseResult.ParseError, R>

export declare const serializeExit: {
  <A, E>(
    value: Exit.Exit<A, E>
  ): <I, EI, R>(self: WithResult<A, I, E, EI, R>) => Effect.Effect<Schema.ExitEncoded<I, EI>, ParseResult.ParseError, R>
  <A, I, E, EI, R>(
    self: WithResult<A, I, E, EI, R>,
    value: Exit.Exit<A, E>
  ): Effect.Effect<Schema.ExitEncoded<I, EI>, ParseResult.ParseError, R>
}

export declare const serializeFailure: {
  <E>(value: E): <A, I, EI, R>(self: WithResult<A, I, E, EI, R>) => Effect.Effect<EI, ParseResult.ParseError, R>
  <A, I, E, EI, R>(self: WithResult<A, I, E, EI, R>, value: E): Effect.Effect<EI, ParseResult.ParseError, R>
}

export declare const serializeSuccess: {
  <A>(value: A): <I, E, EI, R>(self: WithResult<A, I, E, EI, R>) => Effect.Effect<I, ParseResult.ParseError, R>
  <A, I, E, EI, R>(self: WithResult<A, I, E, EI, R>, value: A): Effect.Effect<I, ParseResult.ParseError, R>
}

export interface Serializable<A, I, R> {
  readonly [symbol]: Schema.Schema<A, I, R>
}

export type Context<T> = T extends Serializable<infer _A, infer _I, infer R> ? R : never

export interface SerializableWithResult<S, SI, SR, A, AI, E, EI, RR>
  extends Serializable<S, SI, SR>,
    WithResult<A, AI, E, EI, RR> {}

export type Context<T> =
  T extends SerializableWithResult<infer _S, infer _SI, infer SR, infer _A, infer _AI, infer _E, infer _EI, infer RR>
    ? SR | RR
    : never

export interface WithResult<A, I, E, EI, R> {
  readonly [symbolResult]: {
    readonly Success: Schema.Schema<A, I, R>
    readonly Failure: Schema.Schema<E, EI, R>
  }
}

export type Context<T> = T extends WithResult<infer _A, infer _I, infer _E, infer _EI, infer R> ? R : never

export declare const symbol: typeof symbol

export declare const symbolResult: typeof symbolResult