export declare const exitSchema: <SA, SI, FA, FI, R>(
  self: WithResult<SA, SI, FA, FI, R>
) => Schema.Schema<Exit.Exit<SA, FA>, Schema.ExitEncoded<SI, FI, unknown>, R>

export declare const failureSchema: <SA, SI, FA, FI, R>(self: WithResult<SA, SI, FA, FI, R>) => Schema.Schema<FA, FI, R>

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

export declare const successSchema: <SA, SI, FA, FI, R>(self: WithResult<SA, SI, FA, FI, R>) => Schema.Schema<SA, SI, 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
  ): <SA, SI, FA, FI, R>(
    self: WithResult<SA, SI, FA, FI, R>
  ) => Effect.Effect<Exit.Exit<SA, FA>, ParseResult.ParseError, R>
  <SA, SI, FA, FI, R>(
    self: WithResult<SA, SI, FA, FI, R>,
    value: unknown
  ): Effect.Effect<Exit.Exit<SA, FA>, ParseResult.ParseError, R>
}

export declare const deserializeFailure: {
  (
    value: unknown
  ): <SA, SI, FA, FI, R>(self: WithResult<SA, SI, FA, FI, R>) => Effect.Effect<FA, ParseResult.ParseError, R>
  <SA, SI, FA, FI, R>(self: WithResult<SA, SI, FA, FI, R>, value: unknown): Effect.Effect<FA, ParseResult.ParseError, R>
}

export declare const deserializeSuccess: {
  (
    value: unknown
  ): <SA, SI, FA, FI, R>(self: WithResult<SA, SI, FA, FI, R>) => Effect.Effect<SA, ParseResult.ParseError, R>
  <SA, SI, FA, FI, R>(self: WithResult<SA, SI, FA, FI, R>, value: unknown): Effect.Effect<SA, 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: {
  <SA, FA>(
    value: Exit.Exit<SA, FA>
  ): <SI, FI, R>(
    self: WithResult<SA, SI, FA, FI, R>
  ) => Effect.Effect<Schema.ExitEncoded<SI, FI, unknown>, ParseResult.ParseError, R>
  <SA, SI, FA, FI, R>(
    self: WithResult<SA, SI, FA, FI, R>,
    value: Exit.Exit<SA, FA>
  ): Effect.Effect<Schema.ExitEncoded<SI, FI, unknown>, ParseResult.ParseError, R>
}

export declare const serializeFailure: {
  <FA>(value: FA): <SA, SI, FI, R>(self: WithResult<SA, SI, FA, FI, R>) => Effect.Effect<FI, ParseResult.ParseError, R>
  <SA, SI, FA, FI, R>(self: WithResult<SA, SI, FA, FI, R>, value: FA): Effect.Effect<FI, ParseResult.ParseError, R>
}

export declare const serializeSuccess: {
  <SA>(value: SA): <SI, FA, FI, R>(self: WithResult<SA, SI, FA, FI, R>) => Effect.Effect<SI, ParseResult.ParseError, R>
  <SA, SI, FA, FI, R>(self: WithResult<SA, SI, FA, FI, R>, value: SA): Effect.Effect<SI, ParseResult.ParseError, R>
}

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

export type All =
  | Any
  | Serializable<any, never, unknown>
  | Serializable<never, any, unknown>
  | Serializable<never, never, unknown>

export type Any = Serializable<any, any, unknown>

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

export type Encoded<T> = T extends Serializable<infer _A, infer I, infer _R> ? I : never

export type Type<T> = T extends Serializable<infer A, infer _I, infer _R> ? A : never

export interface SerializableWithResult<A, I, R, Success, SuccessEncoded, Failure, FailureEncoded, ResultR>
  extends Serializable<A, I, R>,
    WithResult<Success, SuccessEncoded, Failure, FailureEncoded, ResultR> {}

export type All = Any | SerializableWithResult<any, any, any, any, any, never, never, unknown>

export type Any = SerializableWithResult<any, any, any, any, any, any, any, unknown>

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

export interface WithResult<Success, SuccessEncoded, Failure, FailureEncoded, ResultR> {
  readonly [symbolResult]: {
    readonly success: Schema.Schema<Success, SuccessEncoded, ResultR>
    readonly failure: Schema.Schema<Failure, FailureEncoded, ResultR>
  }
}

export type All = Any | WithResult<any, any, never, never, unknown>

export type Any = WithResult<any, any, any, any, unknown>

export type Context<T> = T extends WithResult<infer _SA, infer _SI, infer _FA, infer _FI, infer R> ? R : never

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

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

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

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

export declare const symbol: typeof symbol

export declare const symbolResult: typeof symbolResult

export declare const asSerializable: <S extends Serializable.All>(
  serializable: S
) => Serializable<Serializable.Type<S>, Serializable.Encoded<S>, Serializable.Context<S>>

export declare const asSerializableWithResult: <SWR extends SerializableWithResult.All>(
  procedure: SWR
) => SerializableWithResult<
  Serializable.Type<SWR>,
  Serializable.Encoded<SWR>,
  Serializable.Context<SWR>,
  WithResult.Success<SWR>,
  WithResult.SuccessEncoded<SWR>,
  WithResult.Failure<SWR>,
  WithResult.FailureEncoded<SWR>,
  WithResult.Context<SWR>
>

export declare const asWithResult: <WR extends WithResult.All>(
  withExit: WR
) => WithResult<
  WithResult.Success<WR>,
  WithResult.SuccessEncoded<WR>,
  WithResult.Failure<WR>,
  WithResult.FailureEncoded<WR>,
  WithResult.Context<WR>
>