export interface Fork<A> {
  readonly [ForkTypeId]: ForkTypeId
  readonly value: A
}

declare const ForkTypeId: unique symbol

type ForkTypeId = typeof ForkTypeId

declare const fork: <A>(value: A) => Fork<A>

declare const isFork: (u: object) => u is Fork<any>

export interface AnyStructSchema extends Pipeable {
  readonly [Schema.TypeId]: any
  readonly make: any
  readonly Type: any
  readonly Encoded: any
  readonly Context: any
  readonly ast: AST.AST
  readonly fields: Schema.Struct.Fields
  readonly annotations: any
}

export interface AnyTaggedRequestSchema extends AnyStructSchema {
  readonly _tag: string
  readonly success: Schema.Schema.Any
  readonly failure: Schema.Schema.All
}

declare const exitSchema: <R extends Any>(self: R) => Schema.Schema<Exit<R>, ExitEncoded<R>, Context<R>>

declare const fromTaggedRequest: <S extends AnyTaggedRequestSchema>(schema: S) => From<S>

declare const make: <
  const Tag extends string,
  Payload extends AnyStructSchema | Schema.Struct.Fields = Schema.Struct<{}>,
  Success extends Schema.Schema.Any = any,
  Error extends Schema.Schema.All = any,
  const Stream extends boolean = false
>(
  tag: Tag,
  options?: { readonly payload?: Payload; readonly success?: Success; readonly error?: Error; readonly stream?: Stream }
) => Rpc<
  Tag,
  Payload extends Schema.Struct.Fields ? Schema.Struct<Payload> : Payload,
  Stream extends true ? RpcSchema.Stream<Success, Error> : Success,
  Stream extends true ? typeof Schema.Never : Error
>

declare const isRpc: (u: unknown) => u is Rpc<any, any, any>

type AddError<R, Error> =
  R extends Rpc<infer _Tag, infer _Payload, infer _Success, infer _Error, infer _Middleware>
    ? Rpc<_Tag, _Payload, _Success, _Error | Error, _Middleware>
    : never

type AddMiddleware<R, Middleware> =
  R extends Rpc<infer _Tag, infer _Payload, infer _Success, infer _Error, infer _Middleware>
    ? Rpc<_Tag, _Payload, _Success, _Error, _Middleware | Middleware>
    : never

export interface Any extends Pipeable {
  readonly [TypeId]: TypeId
  readonly _tag: string
  readonly key: string
}

export interface AnyWithProps {
  readonly [TypeId]: TypeId
  readonly _tag: string
  readonly key: string
  readonly payloadSchema: AnyStructSchema
  readonly successSchema: Schema.Schema.Any
  readonly errorSchema: Schema.Schema.All
  readonly annotations: Context_.Context<never>
  readonly middlewares: ReadonlySet<RpcMiddleware.TagClassAnyWithProps>
}

type Context<R> =
  R extends Rpc<infer _Tag, infer _Payload, infer _Success, infer _Error, infer _Middleware>
    ? _Payload["Context"] | _Success["Context"] | _Error["Context"]
    : never

type Schema.Schema.Type<ErrorSchema<R>> = Schema.Schema.Type<ErrorSchema<R>>

type Schema.Schema.Encoded<ErrorSchema<R>> = Schema.Schema.Encoded<ErrorSchema<R>>

type ErrorExit<R> = Success<R> extends Stream<infer _A, infer _E, infer _Env> ? _E | Error<R> : Error<R>

type ErrorExitEncoded<R> =
  SuccessEncoded<R> extends Stream<infer _A, infer _E, infer _Env> ? _E | ErrorEncoded<R> : ErrorEncoded<R>

type ErrorSchema<R> =
  R extends Rpc<infer _Tag, infer _Payload, infer _Success, infer _Error, infer _Middleware>
    ? _Error | _Middleware
    : never

type ExcludeProvides<Env, R, Tag> = Exclude<Env, ExtractProvides<R, Tag>>

type Exit_<SuccessExit<R>, ErrorExit<R>> = Exit_<SuccessExit<R>, ErrorExit<R>>

type Schema.ExitEncoded<SuccessExitEncoded<R>, ErrorExitEncoded<R>, Defect> = Schema.ExitEncoded<SuccessExitEncoded<R>, ErrorExitEncoded<R>, Defect>

type ExtractProvides<R, Tag> =
  R extends Rpc<Tag, infer _Payload, infer _Success, infer _Error, infer _Middleware>
    ? _Middleware extends {
        readonly provides: Context_.Tag<infer _I, infer _S>
      }
      ? _I
      : never
    : never

type ExtractTag<R, Tag> =
  R extends Rpc<Tag, infer _Payload, infer _Success, infer _Error, infer _Middleware> ? R : never

export interface From<S extends AnyTaggedRequestSchema> extends Rpc<S["_tag"], S, S["success"], S["failure"]> {}

export interface Handler<Tag extends string> {
  readonly _: unique symbol
  readonly tag: Tag
  readonly handler: (request: any, headers: Headers) => Effect<any, any> | Stream<any, any>
  readonly context: Context<never>
}

type IsStream<R, Tag> =
  R extends Rpc<Tag, infer _Payload, RpcSchema.Stream<infer _A, infer _E>, infer _Error, infer _Middleware>
    ? true
    : never

type Middleware<R> =
  R extends Rpc<infer _Tag, infer _Payload, infer _Success, infer _Error, infer _Middleware>
    ? Context_.Tag.Identifier<_Middleware>
    : never

type MiddlewareClient<R> =
  R extends Rpc<infer _Tag, infer _Payload, infer _Success, infer _Error, infer _Middleware>
    ? _Middleware extends { readonly requiredForClient: true }
      ? RpcMiddleware.ForClient<Context_.Tag.Identifier<_Middleware>>
      : never
    : never

type Payload<R> =
  R extends Rpc<infer _Tag, infer _Payload, infer _Success, infer _Error, infer _Middleware> ? _Payload["Type"] : never

type PayloadConstructor<R> =
  R extends Rpc<infer _Tag, infer _Payload, infer _Success, infer _Error, infer _Middleware>
    ? Schema.Struct.Constructor<_Payload["fields"]> extends infer T
      ? [keyof T] extends [never]
        ? void | {}
        : Schema.Simplify<T>
      : never
    : never

export interface Rpc<
  out Tag extends string,
  out Payload extends AnyStructSchema = Schema.Struct<{}>,
  out Success extends Schema.Schema.Any = typeof Schema.Void,
  out Error extends Schema.Schema.All = typeof Schema.Never,
  out Middleware extends RpcMiddleware.TagClassAny = never
> extends Pipeable {
  readonly [TypeId]: TypeId
  readonly _tag: Tag
  readonly key: string
  readonly payloadSchema: Payload
  readonly successSchema: Success
  readonly errorSchema: Error
  readonly annotations: Context_.Context<never>
  readonly middlewares: ReadonlySet<Middleware>

  /**
   * Set the schema for the success response of the rpc.
   */
  setSuccess<S extends Schema.Schema.Any>(schema: S): Rpc<Tag, Payload, S, Error, Middleware>

  /**
   * Set the schema for the error response of the rpc.
   */
  setError<E extends Schema.Schema.Any>(schema: E): Rpc<Tag, Payload, Success, E, Middleware>

  /**
   * Set the schema for the payload of the rpc.
   */
  setPayload<P extends Schema.Struct<any> | Schema.Struct.Fields>(
    schema: P
  ): Rpc<
    Tag,
    P extends Schema.Struct<infer _> ? P : P extends Schema.Struct.Fields ? Schema.Struct<P> : never,
    Success,
    Error,
    Middleware
  >

  /**
   * Add an `RpcMiddleware` to this procedure.
   */
  middleware<M extends RpcMiddleware.TagClassAny>(middleware: M): Rpc<Tag, Payload, Success, Error, Middleware | M>

  /**
   * Add an annotation on the rpc.
   */
  annotate<I, S>(tag: Context_.Tag<I, S>, value: S): Rpc<Tag, Payload, Success, Error, Middleware>

  /**
   * Merge the annotations of the rpc with the provided context.
   */
  annotateContext<I>(context: Context_.Context<I>): Rpc<Tag, Payload, Success, Error, Middleware>
}

type Success<R> =
  R extends Rpc<infer _Tag, infer _Payload, infer _Success, infer _Error, infer _Middleware> ? _Success["Type"] : never

type SuccessChunk<R> = Success<R> extends Stream<infer _A, infer _E, infer _Env> ? _A : never

type SuccessChunkEncoded<R> = SuccessEncoded<R> extends Stream<infer _A, infer _E, infer _Env> ? _A : never

type SuccessEncoded<R> =
  R extends Rpc<infer _Tag, infer _Payload, infer _Success, infer _Error, infer _Middleware>
    ? _Success["Encoded"]
    : never

type SuccessExit<R> = Success<R> extends infer T ? (T extends Stream<infer _A, infer _E, infer _Env> ? void : T) : never

type SuccessExitEncoded<R> =
  SuccessEncoded<R> extends infer T ? (T extends Stream<infer _A, infer _E, infer _Env> ? void : T) : never

type Tag<R> = R extends Rpc<infer _Tag, infer _Payload, infer _Success, infer _Error, infer _Middleware> ? _Tag : never

type ToHandler<R> =
  R extends Rpc<infer _Tag, infer _Payload, infer _Success, infer _Error, infer _Middleware> ? Handler<_Tag> : never

declare const TypeId: unique symbol

type TypeId = typeof TypeId