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