RpcMiddleware

declare function layerClient<Id, S, R, EX = never, RX = never>(
  tag: Tag<Id, S>,
  service: RpcMiddlewareClient<R> | Effect<RpcMiddlewareClient<R>, EX, RX>,
): Layer<ForClient<Id>, EX, R | Exclude<RX, Scope>>;

interface Any {
  (options: {
    readonly headers: Headers;
    readonly next?: Effect<any, any, any>;
    readonly payload: unknown;
    readonly rpc: AnyWithProps;
  }): Effect<any, any>;
}

interface ForClient<Id> {
  readonly _: typeof _;
  readonly id: Id;
}

interface RpcMiddleware<Provides, E> {
  (options: {
    readonly clientId: number;
    readonly headers: Headers;
    readonly payload: unknown;
    readonly rpc: AnyWithProps;
  }): Effect<Provides, E>;
}

interface RpcMiddlewareClient<R = never> {
  (options: {
    readonly request: Request<Any>;
    readonly rpc: AnyWithProps;
  }): Effect<Request<Any>, never, R>;
}

interface RpcMiddlewareWrap<Provides, E> {
  (options: {
    readonly clientId: number;
    readonly headers: Headers;
    readonly next: Effect<SuccessValue, E, Provides>;
    readonly payload: unknown;
    readonly rpc: AnyWithProps;
  }): Effect<SuccessValue, E>;
}

interface SuccessValue {
  readonly _: typeof _;
}

interface TagClass<Self, Name extends string, Options> extends Base<
  Self,
  Name,
  Options,
  TagClass.Wrap<Options> extends true
    ? RpcMiddlewareWrap<TagClass.Provides<Options>, TagClass.Failure<Options>>
    : RpcMiddleware<TagClass.Service<Options>, TagClass.FailureService<Options>>
> {
  constructor(_: never);
}

interface TagClassAny extends Tag<any, any> {
  readonly [TypeId]: typeof TypeId;
  readonly failure: All;
  readonly optional: boolean;
  readonly provides?: any;
  readonly requiredForClient: boolean;
  readonly wrap: boolean;
}

interface TagClassAnyWithProps extends Tag<
  any,
  RpcMiddleware<any, any> | RpcMiddlewareWrap<any, any>
> {
  readonly [TypeId]: typeof TypeId;
  readonly failure: All;
  readonly optional: boolean;
  readonly provides?: any;
  readonly requiredForClient: boolean;
  readonly wrap: boolean;
}

declare function Tag<Self>(): <
  Name extends string,
  Options extends {
    readonly failure?: any;
    readonly optional?: boolean;
    readonly provides?: any;
    readonly requiredForClient?: boolean;
    readonly wrap?: boolean;
  },
>(
  id: Name,
  options?: Options,
) => TagClass<Self, Name, Options>;

declare const TypeId: unique symbol;

type TypeId = typeof TypeId;