Rpc

interface AnySchema extends Pipeable {
  [key: number]: any;
  readonly annotations: any;
  readonly ast: AST;
  readonly Context: any;
  readonly Encoded: any;
  readonly make?: (params: any, ...rest: readonly Array<any>) => any;
  readonly Type: any;
}

interface AnyTaggedRequestSchema extends AnySchema {
  [key: number]: any;
  readonly _tag: string;
  readonly failure: All;
  readonly success: Any;
}

declare function exitSchema<R extends Any>(self: R): any;

declare function fromTaggedRequest<S extends AnyTaggedRequestSchema>(schema: S): From<S>;

declare function make<
  Tag extends string,
  Payload extends any = Void,
  Success extends Any = Void,
  Error extends All = Never,
  Stream extends boolean = false,
>(
  tag: Tag,
  options?: {
    readonly defect?: any;
    readonly error?: Error;
    readonly payload?: Payload;
    readonly primaryKey?: [Payload] extends [Fields]
      ? (
          payload: Simplify<
            View<
              NoInfer<Payload>,
              "Type",
              TypeOptionalKeys<NoInfer<Payload>>,
              TypeMutableKeys<NoInfer<Payload>>
            >
          >,
        ) => string
      : never;
    readonly stream?: Stream;
    readonly success?: Success;
  },
): Rpc<
  Tag,
  Payload extends Fields ? Struct<Payload> : Payload,
  Stream extends true ? Stream<Success, Error> : Success,
  Stream extends true ? Never : Error
>;

declare function isRpc(u: unknown): u is Rpc<any, any, any, Never, never>;

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

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

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

interface AnyWithProps {
  readonly _tag: string;
  readonly [TypeId]: typeof TypeId;
  readonly annotations: Context<never>;
  readonly defectSchema: any;
  readonly errorSchema: All;
  readonly key: string;
  readonly middlewares: ReadonlySet<TagClassAnyWithProps>;
  readonly payloadSchema: AnySchema;
  readonly successSchema: Any;
}

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

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

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

type ErrorExit<R> =
  SuccessSchema<R> extends RpcSchema.Stream<infer _A, infer _E> ? _E["Type"] | Error<R> : Error<R>;

type ErrorExitEncoded<R> =
  SuccessSchema<R> extends RpcSchema.Stream<infer _A, infer _E>
    ? _E["Encoded"] | 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 extends Any, Tag extends string> = Exclude<
  Env,
  ExtractProvides<R, Tag>
>;

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

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

type ExtractProvides<R extends Any, Tag extends string> =
  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 extends Any, Tag extends string> =
  R extends Rpc<Tag, infer _Payload, infer _Success, infer _Error, infer _Middleware> ? R : never;

interface From<S extends AnyTaggedRequestSchema> extends Rpc<
  S["_tag"],
  S,
  S["success"],
  S["failure"]
> {
  constructor(_: never);
}

interface Handler<Tag extends string> {
  readonly _: typeof _;
  readonly context: never;
  readonly handler: (
    request: any,
    options: {
      readonly clientId: number;
      readonly headers: Headers;
    },
  ) => Effect<any, any, never> | Stream<any, any, never>;
  readonly tag: Tag;
}

type IsStream<R extends Any, Tag extends string> =
  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>
    ? _Payload extends {
        readonly fields: Schema.Struct.Fields;
      }
      ? Schema.Simplify<Schema.Struct.Constructor<_Payload["fields"]>>
      : _Payload["Type"]
    : never;

type Prefixed<Rpcs extends Any, Prefix extends string> =
  Rpcs extends Rpc<infer _Tag, infer _Payload, infer _Success, infer _Error, infer _Middleware>
    ? Rpc<`${Prefix}${_Tag}`, _Payload, _Success, _Error, _Middleware>
    : never;

type ResultFrom<R extends Any, Context> =
  R extends Rpc<infer _Tag, infer _Payload, infer _Success, infer _Error, infer _Middleware>
    ? [_Success] extends [RpcSchema.Stream<infer _SA, infer _SE>]
      ?
          | Stream<_SA["Type"], _SE["Type"] | _Error["Type"], Context>
          | Effect<
              ReadonlyMailbox<_SA["Type"], _SE["Type"] | _Error["Type"]>,
              _SE["Type"] | Schema.Schema.Type<_Error>,
              Context
            >
      : Effect<_Success["Type"], _Error["Type"], Context>
    : never;

interface Rpc<
  in out Tag extends string,
  out Payload extends AnySchema = typeof Schema.Void,
  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 {
  constructor(_: never);
  readonly _tag: Tag;
  readonly [TypeId]: typeof TypeId;
  readonly annotations: Context<never>;
  readonly defectSchema: any;
  readonly errorSchema: Error;
  readonly key: string;
  readonly middlewares: ReadonlySet<Middleware>;
  readonly payloadSchema: Payload;
  readonly successSchema: Success;
  annotate<I, S>(tag: Tag<I, S>, value: S): Rpc<Tag, Payload, Success, Error, Middleware>;
  annotateContext<I>(context: Context<I>): Rpc<Tag, Payload, Success, Error, Middleware>;
  middleware<M extends TagClassAny>(
    middleware: M,
  ): Rpc<Tag, Payload, Success, Error, Middleware | M>;
  prefix<Prefix extends string>(
    prefix: Prefix,
  ): Rpc<`${Prefix}${Tag}`, Payload, Success, Error, Middleware>;
  setError<E extends Any>(schema: E): Rpc<Tag, Payload, Success, E, Middleware>;
  setPayload<P extends Fields | Struct<any>>(
    schema: P,
  ): Rpc<
    Tag,
    P extends Struct<_> ? P : P extends Fields ? Struct<P> : never,
    Success,
    Error,
    Middleware
  >;
  setSuccess<S extends Any>(schema: S): Rpc<Tag, Payload, S, 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> =
  SuccessSchema<R> extends infer S
    ? S extends RpcSchema.Stream<infer _A, infer _E>
      ? void
      : Schema.Schema.Type<S>
    : never;

type SuccessExitEncoded<R> =
  SuccessSchema<R> extends infer S
    ? S extends RpcSchema.Stream<infer _A, infer _E>
      ? void
      : Schema.Schema.Encoded<S>
    : never;

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

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

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

type ToHandlerFn<Current extends Any, R = any> = (
  payload: Payload<Current>,
  options: {
    readonly clientId: number;
    readonly headers: Headers;
  },
) => ResultFrom<Current, R> | Wrapper<ResultFrom<Current, R>>;

declare const TypeId: unique symbol;

type TypeId = typeof TypeId;

declare const fork: <A extends object>(value: A) => A extends Wrapper<infer _> ? A : Wrapper<A>;

declare function isWrapper(u: object): u is Wrapper<any>;

declare const uninterruptible: <A extends object>(
  value: A,
) => A extends Wrapper<infer _> ? A : Wrapper<A>;

declare function wrap(options: {
  readonly fork?: boolean;
  readonly uninterruptible?: boolean;
}): <A extends object>(value: A) => A extends Wrapper<_> ? A : Wrapper<A>;

interface Wrapper<A> {
  readonly [WrapperTypeId]: typeof WrapperTypeId;
  readonly fork: boolean;
  readonly uninterruptible: boolean;
  readonly value: A;
}

declare const WrapperTypeId: unique symbol;

type WrapperTypeId = typeof WrapperTypeId;