McpServer

declare const run: (options: {
  readonly name: string;
  readonly version: string;
}) => Effect.Effect<never, never, McpServer | RpcServer.Protocol>;

declare const elicit: <A, I extends Record<string, any>, R>(options: {
  readonly message: string;
  readonly schema: Schema.Schema<A, I, R>;
}) => Effect.Effect<A, ElicitationDeclined, McpServerClient | R>;

declare function layer(options: {
  readonly name: string;
  readonly version: string;
}): Layer<McpServerClient | McpServer, never, Protocol>;

declare function layerHttp<I = Default>(options: {
  readonly name: string;
  readonly path: PathInput;
  readonly routerTag?: any;
  readonly version: string;
}): Layer<McpServerClient | McpServer>;

declare function layerHttpRouter(options: {
  readonly name: string;
  readonly path: PathInput;
  readonly version: string;
}): Layer<McpServerClient | McpServer, never, HttpRouter>;

declare function layerStdio<EIn, RIn, EOut, ROut>(options: {
  readonly name: string;
  readonly stdin: Stream<Uint8Array<ArrayBufferLike>, EIn, RIn>;
  readonly stdout: Sink<unknown, string | Uint8Array<ArrayBufferLike>, unknown, EOut, ROut>;
  readonly version: string;
}): Layer<McpServerClient | McpServer, never, RIn | ROut>;

declare class McpServer extends any {
  constructor();
  static readonly layer: Layer<McpServerClient | McpServer>;
  static readonly make: Effect<any, unknown, unknown>;
}

type ResourceCompletions<Schemas extends ReadonlyArray<Schema.Schema.Any>> = {
  [K in Extract<keyof Schemas, `${number}`>]: (
    input: string,
  ) => Effect.Effect<Array<Schema.Schema.Type<Schemas[K]>>, any, any>;
};

type ValidateCompletions<Completions, Keys extends string> = Completions & {
  [K in keyof Completions]: K extends Keys ? (input: string) => any : never;
};

declare function prompt<
  E,
  R,
  Params = {},
  ParamsI extends Record<string, string> = {},
  ParamsR = never,
  Completions extends {
    [K in string | number | symbol]: (input: string) => Effect<Array<Params[K]>, any, any>;
  } = {},
>(options: {
  readonly completion?: ValidateCompletions<Completions, Extract<keyof Params, string>>;
  readonly content: (params: Params) => Effect<string | Array<any>, E, R>;
  readonly description?: string;
  readonly name: string;
  readonly parameters?: any;
}): Layer<never, never, Exclude<R, McpServerClient> | Exclude<ParamsR, McpServerClient>>;

declare function registerPrompt<
  E,
  R,
  Params = {},
  ParamsI extends Record<string, string> = {},
  ParamsR = never,
  Completions extends {
    [K in string | number | symbol]: (input: string) => Effect<Array<Params[K]>, any, any>;
  } = {},
>(options: {
  readonly completion?: ValidateCompletions<Completions, Extract<keyof Params, string>>;
  readonly content: (params: Params) => Effect<string | Array<any>, E, R>;
  readonly description?: string;
  readonly name: string;
  readonly parameters?: any;
}): Effect<
  void,
  never,
  McpServer | Exclude<R, McpServerClient> | Exclude<ParamsR, McpServerClient>
>;

declare const registerResource: {
  <E, R>(options: {
    readonly audience?: ReadonlyArray<"user" | "assistant">;
    readonly content: Effect.Effect<typeof ReadResourceResult.Type | string | Uint8Array, E, R>;
    readonly description?: string;
    readonly mimeType?: string;
    readonly name: string;
    readonly priority?: number;
    readonly uri: string;
  }): Effect<void, never, McpServer | Exclude<R, McpServerClient>>;
  <Schemas extends readonly Array<Any>>(segments: TemplateStringsArray, ...schemas: Schemas & { [K in string | number | symbol]: unknown }): <E, R, Completions extends Partial<ResourceCompletions<Schemas>> = {}>(options: {
    readonly audience?: ReadonlyArray<"user" | "assistant">;
    readonly completion?: ValidateCompletions<Completions, keyof ResourceCompletions<Schemas>>;
    readonly content: (uri: string, ...params: { [K in keyof Schemas]: Schemas[K]["Type"] }) => Effect.Effect<typeof ReadResourceResult.Type | string | Uint8Array, E, R>;
    readonly description?: string;
    readonly mimeType?: string;
    readonly name: string;
    readonly priority?: number;
  }) => Effect<void, never, McpServer | Exclude<R, McpServerClient> | Exclude<Completions[keyof Completions] extends (input: string) => Ret ? Ret extends Effect<_A, _E, _R> ? _R : never : never, McpServerClient>>;
}

declare const resource: {
  <E, R>(options: {
    readonly audience?: ReadonlyArray<"user" | "assistant">;
    readonly content: Effect.Effect<typeof ReadResourceResult.Type | string | Uint8Array, E, R>;
    readonly description?: string;
    readonly mimeType?: string;
    readonly name: string;
    readonly priority?: number;
    readonly uri: string;
  }): Layer<never, never, Exclude<R, McpServerClient>>;
  <Schemas extends readonly Array<Any>>(segments: TemplateStringsArray, ...schemas: Schemas & { [K in string | number | symbol]: unknown }): <E, R, Completions extends Partial<ResourceCompletions<Schemas>> = {}>(options: {
    readonly audience?: ReadonlyArray<"user" | "assistant">;
    readonly completion?: ValidateCompletions<Completions, keyof ResourceCompletions<Schemas>>;
    readonly content: (uri: string, ...params: { [K in keyof Schemas]: Schemas[K]["Type"] }) => Effect.Effect<typeof ReadResourceResult.Type | string | Uint8Array, E, R>;
    readonly description?: string;
    readonly mimeType?: string;
    readonly name: string;
    readonly priority?: number;
  }) => Layer<never, never, Exclude<R, McpServerClient> | Exclude<Completions[keyof Completions] extends (input: string) => Ret ? Ret extends Effect<_A, _E, _R> ? _R : never : never, McpServerClient>>;
}

declare const registerToolkit: <Tools extends Record<string, AiTool.Any>>(
  toolkit: Toolkit.Toolkit<Tools>,
) => Effect.Effect<
  void,
  never,
  McpServer | AiTool.HandlersFor<Tools> | Exclude<AiTool.Requirements<Tools>, McpServerClient>
>;

declare function toolkit<Tools extends Record<string, Any>>(
  toolkit: Toolkit<Tools>,
): Layer<never, never, HandlersFor<Tools> | Exclude<Requirements<Tools>, McpServerClient>>;