McpSchema

declare const INTERNAL_ERROR_CODE: -32603;

declare const INVALID_PARAMS_ERROR_CODE: -32602;

declare const INVALID_REQUEST_ERROR_CODE: -32600;

declare const METHOD_NOT_FOUND_ERROR_CODE: -32601;

declare const PARSE_ERROR_CODE: -32700;

declare class InternalError extends {
  readonly _tag: "InternalError";
  readonly code: -32603;
  readonly data?: any;
  readonly message: string;
} & YieldableError<this> {
  constructor(...args: [props: {
    readonly _tag?: "InternalError";
    readonly code?: -32603;
    readonly data?: any;
    readonly message: string;
  }, options?: MakeOptions]);
  static readonly notImplemented: InternalError;
}

declare class InvalidParams extends {
  readonly _tag: "InvalidParams";
  readonly code: -32602;
  readonly data?: any;
  readonly message: string;
} & YieldableError<this> {
  constructor(...args: [props: {
    readonly _tag?: "InvalidParams";
    readonly code?: -32602;
    readonly data?: any;
    readonly message: string;
  }, options?: MakeOptions]);
}

declare class InvalidRequest extends {
  readonly _tag: "InvalidRequest";
  readonly code: -32600;
  readonly data?: any;
  readonly message: string;
} & YieldableError<this> {
  constructor(...args: [props: {
    readonly _tag?: "InvalidRequest";
    readonly code?: -32600;
    readonly data?: any;
    readonly message: string;
  }, options?: MakeOptions]);
}

declare const McpError: Union<
  readonly [
    typeof ParseError,
    typeof InvalidRequest,
    typeof MethodNotFound,
    typeof InvalidParams,
    typeof InternalError,
    typeof McpErrorBase,
  ]
>;

declare class MethodNotFound extends {
  readonly _tag: "MethodNotFound";
  readonly code: -32601;
  readonly data?: any;
  readonly message: string;
} & YieldableError<this> {
  constructor(...args: [props: {
    readonly _tag?: "MethodNotFound";
    readonly code?: -32601;
    readonly data?: any;
    readonly message: string;
  }, options?: MakeOptions]);
}

declare class ParseError extends {
  readonly _tag: "ParseError";
  readonly code: -32700;
  readonly data?: any;
  readonly message: string;
} & YieldableError<this> {
  constructor(...args: [props: {
    readonly _tag?: "ParseError";
    readonly code?: -32700;
    readonly data?: any;
    readonly message: string;
  }, options?: MakeOptions]);
}

declare function isParam(schema: Constraint): schema is Param<string, Top>;

declare const LoggingLevel: Schema.Literals<
  ["debug", "info", "notice", "warning", "error", "critical", "alert", "emergency"]
>;

type LoggingLevel = typeof LoggingLevel.Type;

declare class LoggingMessageNotification extends ({}) {
  constructor(_: never);
}

declare class SetLevel extends ({}) {
  constructor(_: never);
}

declare class McpServerClientMiddleware extends Shape<"effect/ai/McpSchema/McpServerClientMiddleware", RpcMiddleware<McpServerClient, never, never>, this> & {
  readonly "~effect/rpc/RpcMiddleware": {
    readonly clientError: never;
    readonly error: Never;
    readonly provides: McpServerClient;
    readonly requires: never;
  };
} {
  constructor(_: never);
}

type Cursor = typeof Cursor.Type;

interface optionalWithDefault<
  S extends Schema.Constraint & Schema.WithoutConstructorDefault,
> extends withConstructorDefault<
  Schema.decodeTo<Schema.toType<Schema.optionalKey<S>>, Schema.optionalKey<S>>
> {
  constructor(_: never);
}

type ProgressToken = typeof ProgressToken.Type;

type RequestId = typeof RequestId.Type;

type Role = typeof Role.Type;

declare function param<Name extends string, S extends Constraint>(
  name: Name,
  schema: S,
): Param<Name, S>;

interface Param<Name extends string, S extends Schema.Constraint> extends BottomLazy<
  S["ast"],
  Param<Name, S>,
  S["~type.parameters"],
  S["~type.mutability"],
  S["~type.optionality"],
  S["~type.constructor.default"],
  S["~encoded.mutability"],
  S["~encoded.optionality"]
> {
  constructor(_: never);
  readonly "~effect/ai/McpSchema/ParamSchema": "~effect/ai/McpSchema/ParamSchema";
  readonly "~type.make": S["~type.make"];
  readonly "~type.make.in": S["~type.make.in"];
  readonly DecodingServices: S["DecodingServices"];
  readonly Encoded: S["Encoded"];
  readonly EncodingServices: S["EncodingServices"];
  readonly Iso: S["Iso"];
  readonly name: Name;
  readonly Rebuild: Param<Name, S>;
  readonly schema: S;
  readonly Type: S["Type"];
}

declare class CallTool extends ({}) {
  constructor(_: never);
}

declare class CancelledNotification extends ({}) {
  constructor(_: never);
}

type ClientFailureEncoded = FailureEncoded<typeof ServerRequestRpcs>;

type ClientNotificationEncoded = NotificationEncoded<typeof ClientNotificationRpcs>;

declare class ClientNotificationRpcs extends ({}) {
  constructor(_: never);
}

type ClientRequestEncoded = RequestEncoded<typeof ClientRequestRpcs>;

declare class ClientRequestRpcs extends ({}) {
  constructor(_: never);
}

declare class ClientRpcs extends ({}) {
  constructor(_: never);
}

type ClientSuccessEncoded = SuccessEncoded<typeof ServerRequestRpcs>;

declare class Complete extends ({}) {
  constructor(_: never);
}

declare class CreateMessage extends ({}) {
  constructor(_: never);
}

declare class Elicit extends ({}) {
  constructor(_: never);
}

type FailureEncoded<Group extends RpcGroup.Any> =
  RpcGroup.Rpcs<Group> extends infer Rpc
    ? Rpc extends Rpc.Rpc<
        infer _Tag,
        infer _Payload,
        infer _Success,
        infer _Error,
        infer _Middleware
      >
      ? {
          readonly _tag: "Failure";
          readonly error: _Error["Encoded"];
          readonly id: string | number;
        }
      : never
    : never;

type FromClientEncoded = ClientRequestEncoded | ClientNotificationEncoded;

type FromServerEncoded = ServerResultEncoded | ServerNotificationEncoded;

declare class GetPrompt extends ({}) {
  constructor(_: never);
}

declare class Initialize extends ({}) {
  constructor(_: never);
}

declare class InitializedNotification extends ({}) {
  constructor(_: never);
}

declare class ListPrompts extends ({}) {
  constructor(_: never);
}

declare class ListResources extends ({}) {
  constructor(_: never);
}

declare class ListResourceTemplates extends ({}) {
  constructor(_: never);
}

declare class ListRoots extends ({}) {
  constructor(_: never);
}

declare class ListTools extends ({}) {
  constructor(_: never);
}

type NotificationEncoded<Group extends RpcGroup.Any> =
  RpcGroup.Rpcs<Group> extends infer Rpc
    ? Rpc extends Rpc.Rpc<
        infer _Tag,
        infer _Payload,
        infer _Success,
        infer _Error,
        infer _Middleware
      >
      ? {
          readonly _tag: "Notification";
          readonly method: _Tag;
          readonly payload: _Payload["Encoded"];
        }
      : never
    : never;

declare class Ping extends ({}) {
  constructor(_: never);
}

declare class ProgressNotification extends ({}) {
  constructor(_: never);
}

declare class PromptListChangedNotification extends ({}) {
  constructor(_: never);
}

declare class ReadResource extends ({}) {
  constructor(_: never);
}

type RequestEncoded<Group extends RpcGroup.Any> =
  RpcGroup.Rpcs<Group> extends infer Rpc
    ? Rpc extends Rpc.Rpc<
        infer _Tag,
        infer _Payload,
        infer _Success,
        infer _Error,
        infer _Middleware
      >
      ? {
          readonly _tag: "Request";
          readonly id: string | number;
          readonly method: _Tag;
          readonly payload: _Payload["Encoded"];
        }
      : never
    : never;

declare class ResourceListChangedNotification extends ({}) {
  constructor(_: never);
}

declare class ResourceUpdatedNotification extends ({}) {
  constructor(_: never);
}

declare class RootsListChangedNotification extends ({}) {
  constructor(_: never);
}

type ServerFailureEncoded = FailureEncoded<typeof ClientRequestRpcs>;

type ServerNotificationEncoded = NotificationEncoded<typeof ServerNotificationRpcs>;

declare class ServerNotificationRpcs extends ({}) {
  constructor(_: never);
}

type ServerRequestEncoded = RequestEncoded<typeof ServerRequestRpcs>;

declare class ServerRequestRpcs extends ({}) {
  constructor(_: never);
}

type ServerResultEncoded = ServerSuccessEncoded | ServerFailureEncoded;

type ServerSuccessEncoded = SuccessEncoded<typeof ClientRequestRpcs>;

declare class Subscribe extends ({}) {
  constructor(_: never);
}

type SuccessEncoded<Group extends RpcGroup.Any> =
  RpcGroup.Rpcs<Group> extends infer Rpc
    ? Rpc extends Rpc.Rpc<
        infer _Tag,
        infer _Payload,
        infer _Success,
        infer _Error,
        infer _Middleware
      >
      ? {
          readonly _tag: "Success";
          readonly id: string | number;
          readonly result: _Success["Encoded"];
        }
      : never
    : never;

declare class ToolListChangedNotification extends ({}) {
  constructor(_: never);
}

declare class Unsubscribe extends ({}) {
  constructor(_: never);
}

declare class Annotations extends {
  readonly audience?: readonly Array<"user" | "assistant">;
  readonly priority?: number;
} {
  constructor(_: never);
}

declare class AudioContent extends {
  readonly annotations?: Annotations;
  readonly data: Uint8Array<ArrayBufferLike>;
  readonly mimeType: string;
  readonly type: "audio";
} {
  constructor(_: never);
}

declare class BlobResourceContents extends {
  readonly _meta?: {
    [key: string]: Json;
  };
  readonly blob: Uint8Array<ArrayBufferLike>;
  readonly mimeType?: string;
  readonly uri: string;
} {
  constructor(_: never);
}

declare class CallToolResult extends {
  readonly _meta?: {
    [key: string]: Json;
  };
  readonly content: readonly Array<TextContent | ImageContent | AudioContent | EmbeddedResource | ResourceLink>;
  readonly isError?: boolean;
  readonly structuredContent?: any;
} {
  constructor(...args: [props: {
    readonly _meta?: {
      [key: string]: unknown;
    };
    readonly content: readonly Array<{
      readonly annotations?: {
        readonly audience?: readonly Array<"user" | "assistant">;
        readonly priority?: number;
      };
      readonly text: string;
      readonly type?: "text";
    } | {
      readonly annotations?: {
        readonly audience?: readonly Array<"user" | "assistant">;
        readonly priority?: number;
      };
      readonly data: Uint8Array<ArrayBufferLike>;
      readonly mimeType: string;
      readonly type?: "image";
    } | {
      readonly annotations?: {
        readonly audience?: readonly Array<"user" | "assistant">;
        readonly priority?: number;
      };
      readonly data: Uint8Array<ArrayBufferLike>;
      readonly mimeType: string;
      readonly type?: "audio";
    } | {
      readonly annotations?: {
        readonly audience?: readonly Array<"user" | "assistant">;
        readonly priority?: number;
      };
      readonly resource: {
        readonly _meta?: {
          [key: string]: unknown;
        };
        readonly mimeType?: string;
        readonly text: string;
        readonly uri: string;
      } | {
        readonly _meta?: {
          [key: string]: unknown;
        };
        readonly blob: Uint8Array<ArrayBufferLike>;
        readonly mimeType?: string;
        readonly uri: string;
      };
      readonly type?: "resource";
    } | {
      readonly _meta?: {
        [key: string]: unknown;
      };
      readonly annotations?: {
        readonly audience?: readonly Array<"user" | "assistant">;
        readonly priority?: number;
      };
      readonly description?: string;
      readonly mimeType?: string;
      readonly name: string;
      readonly size?: number;
      readonly title?: string;
      readonly type?: "resource_link";
      readonly uri: string;
    }>;
    readonly isError?: boolean;
    readonly structuredContent?: any;
  }, options?: MakeOptions]);
}

declare class ClientCapabilities extends {
  readonly elicitation?: {};
  readonly experimental?: {
    [key: string]: {};
  };
  readonly extensions?: {
    [key: `${string}/${string}`]: Json;
  };
  readonly roots?: {
    readonly listChanged?: boolean;
  };
  readonly sampling?: {};
} {
  constructor(...args: [props?: {
    readonly elicitation?: {};
    readonly experimental?: {
      [key: string]: {};
    };
    readonly extensions?: {
      [key: `${string}/${string}`]: unknown;
    };
    readonly roots?: {
      readonly listChanged?: boolean;
    };
    readonly sampling?: {};
  }, options?: MakeOptions]);
}

declare class CompleteResult extends {
  readonly completion: {
    readonly hasMore?: boolean;
    readonly total?: number;
    readonly values: readonly Array<string>;
  };
} {
  constructor(_: never);
  static readonly empty: CompleteResult;
}

declare const ContentBlock: Union<
  readonly [
    typeof TextContent,
    typeof ImageContent,
    typeof AudioContent,
    typeof EmbeddedResource,
    typeof ResourceLink,
  ]
>;

declare class CreateMessageResult extends {
  readonly content: TextContent | ImageContent | AudioContent;
  readonly model: string;
  readonly role: "user" | "assistant";
  readonly stopReason?: string;
} {
  constructor(...args: [props: {
    readonly content: {
      readonly annotations?: {
        readonly audience?: readonly Array<"user" | "assistant">;
        readonly priority?: number;
      };
      readonly text: string;
      readonly type?: "text";
    } | {
      readonly annotations?: {
        readonly audience?: readonly Array<"user" | "assistant">;
        readonly priority?: number;
      };
      readonly data: Uint8Array<ArrayBufferLike>;
      readonly mimeType: string;
      readonly type?: "image";
    } | {
      readonly annotations?: {
        readonly audience?: readonly Array<"user" | "assistant">;
        readonly priority?: number;
      };
      readonly data: Uint8Array<ArrayBufferLike>;
      readonly mimeType: string;
      readonly type?: "audio";
    };
    readonly model: string;
    readonly role: "user" | "assistant";
    readonly stopReason?: string;
  }, options?: MakeOptions]);
}

declare const Cursor: typeof Schema.String;

declare class ElicitAcceptResult extends {
  readonly _meta?: {
    [key: string]: Json;
  };
  readonly action: "accept";
  readonly content: any;
} {
  constructor(...args: [props: {
    readonly _meta?: {
      [key: string]: unknown;
    };
    readonly action: "accept";
    readonly content: any;
  }, options?: MakeOptions]);
}

declare class ElicitationDeclined extends {
  readonly _tag: "ElicitationDeclined";
  readonly cause?: unknown;
  readonly request: {
    readonly message: string;
    readonly requestedSchema: any;
  };
} & YieldableError<this> {
  constructor(...args: [props: {
    readonly _tag?: "ElicitationDeclined";
    readonly cause?: unknown;
    readonly request: {
      readonly message: string;
      readonly requestedSchema: any;
    };
  }, options?: MakeOptions]);
}

declare class ElicitDeclineResult extends {
  readonly _meta?: {
    [key: string]: Json;
  };
  readonly action: "cancel" | "decline";
} {
  constructor(...args: [props: {
    readonly _meta?: {
      [key: string]: unknown;
    };
    readonly action: "cancel" | "decline";
  }, options?: MakeOptions]);
}

declare const ElicitResult: Union<readonly [typeof ElicitAcceptResult, typeof ElicitDeclineResult]>;

declare class EmbeddedResource extends {
  readonly annotations?: Annotations;
  readonly resource: TextResourceContents | BlobResourceContents;
  readonly type: "resource";
} {
  constructor(_: never);
}

declare class GetPromptResult extends {
  readonly _meta?: {
    [key: string]: Json;
  };
  readonly description?: string;
  readonly messages: readonly Array<PromptMessage>;
} {
  constructor(...args: [props: {
    readonly _meta?: {
      [key: string]: unknown;
    };
    readonly description?: string;
    readonly messages: readonly Array<{
      readonly content: {
        readonly annotations?: {
          readonly audience?: readonly Array<... | ...>;
          readonly priority?: number;
        };
        readonly text: string;
        readonly type?: "text";
      } | {
        readonly annotations?: {
          readonly audience?: readonly Array<... | ...>;
          readonly priority?: number;
        };
        readonly data: Uint8Array<ArrayBufferLike>;
        readonly mimeType: string;
        readonly type?: "image";
      } | {
        readonly annotations?: {
          readonly audience?: readonly Array<... | ...>;
          readonly priority?: number;
        };
        readonly data: Uint8Array<ArrayBufferLike>;
        readonly mimeType: string;
        readonly type?: "audio";
      } | {
        readonly annotations?: {
          readonly audience?: readonly Array<... | ...>;
          readonly priority?: number;
        };
        readonly resource: {
          readonly _meta?: {
            [key: string]: unknown;
          };
          readonly mimeType?: string;
          readonly text: string;
          readonly uri: string;
        } | {
          readonly _meta?: {
            [key: string]: unknown;
          };
          readonly blob: Uint8Array<ArrayBufferLike>;
          readonly mimeType?: string;
          readonly uri: string;
        };
        readonly type?: "resource";
      } | {
        readonly _meta?: {
          [key: string]: unknown;
        };
        readonly annotations?: {
          readonly audience?: readonly Array<... | ...>;
          readonly priority?: number;
        };
        readonly description?: string;
        readonly mimeType?: string;
        readonly name: string;
        readonly size?: number;
        readonly title?: string;
        readonly type?: "resource_link";
        readonly uri: string;
      };
      readonly role: "user" | "assistant";
    }>;
  }, options?: MakeOptions]);
}

declare class ImageContent extends {
  readonly annotations?: Annotations;
  readonly data: Uint8Array<ArrayBufferLike>;
  readonly mimeType: string;
  readonly type: "image";
} {
  constructor(_: never);
}

declare class Implementation extends {
  readonly name: string;
  readonly title?: string;
  readonly version: string;
} {
  constructor(_: never);
}

declare class InitializeResult extends {
  readonly _meta?: {
    [key: string]: Json;
  };
  readonly capabilities: ServerCapabilities;
  readonly instructions?: string;
  readonly protocolVersion: string;
  readonly serverInfo: Implementation;
} {
  constructor(_: never);
}

declare class ListPromptsResult extends {
  readonly _meta?: {
    [key: string]: Json;
  };
  readonly nextCursor?: string;
  readonly prompts: readonly Array<Prompt>;
} {
  constructor(...args: [props: {
    readonly _meta?: {
      [key: string]: unknown;
    };
    readonly nextCursor?: string;
    readonly prompts: readonly Array<Prompt>;
  }, options?: MakeOptions]);
}

declare class ListResourcesResult extends {
  readonly _meta?: {
    [key: string]: Json;
  };
  readonly nextCursor?: string;
  readonly resources: readonly Array<Resource>;
} {
  constructor(...args: [props: {
    readonly _meta?: {
      [key: string]: unknown;
    };
    readonly nextCursor?: string;
    readonly resources: readonly Array<Resource>;
  }, options?: MakeOptions]);
}

declare class ListResourceTemplatesResult extends {
  readonly _meta?: {
    [key: string]: Json;
  };
  readonly nextCursor?: string;
  readonly resourceTemplates: readonly Array<ResourceTemplate>;
} {
  constructor(...args: [props: {
    readonly _meta?: {
      [key: string]: unknown;
    };
    readonly nextCursor?: string;
    readonly resourceTemplates: readonly Array<ResourceTemplate>;
  }, options?: MakeOptions]);
}

declare class ListRootsResult extends {
  readonly roots: readonly Array<Root>;
} {
  constructor(...args: [props: {
    readonly roots: readonly Array<Root>;
  }, options?: MakeOptions]);
}

declare class ListToolsResult extends {
  readonly _meta?: {
    [key: string]: Json;
  };
  readonly nextCursor?: string;
  readonly tools: readonly Array<Tool>;
} {
  constructor(...args: [props: {
    readonly _meta?: {
      [key: string]: unknown;
    };
    readonly nextCursor?: string;
    readonly tools: readonly Array<Tool>;
  }, options?: MakeOptions]);
}

declare class McpErrorBase extends {
  readonly code: number;
  readonly data?: any;
  readonly message: string;
} {
  constructor(...args: [props: {
    readonly code: number;
    readonly data?: any;
    readonly message: string;
  }, options?: MakeOptions]);
}

declare class ModelHint extends {
  readonly name?: string;
} {
  constructor(_: never);
}

declare class ModelPreferences extends {
  readonly costPriority?: number;
  readonly hints?: readonly Array<ModelHint>;
  readonly intelligencePriority?: number;
  readonly speedPriority?: number;
} {
  constructor(...args: [props?: {
    readonly costPriority?: number;
    readonly hints?: readonly Array<{
      readonly name?: string;
    }>;
    readonly intelligencePriority?: number;
    readonly speedPriority?: number;
  }, options?: MakeOptions]);
}

declare class NotificationMeta extends {
  readonly _meta?: {
    [key: string]: Json;
  };
} {
  constructor(_: never);
}

declare function optional<S extends Constraint>(schema: S): decodeTo<optional<S>, optionalKey<S>>;

declare const optionalWithDefault: <S extends Constraint & WithoutConstructorDefault>(
  schema: S,
  defaultValue: () => S["Type"],
) => optionalWithDefault<S>;

declare class PaginatedRequestMeta extends {
  readonly _meta?: {
    readonly progressToken?: string | number;
  };
  readonly cursor?: string;
} {
  constructor(_: never);
}

declare class PaginatedResultMeta extends {
  readonly _meta?: {
    [key: string]: Json;
  };
  readonly nextCursor?: string;
} {
  constructor(_: never);
}

declare const ProgressToken: Schema.Union<[typeof Schema.String, typeof Schema.Finite]>;

declare class Prompt extends {
  readonly arguments?: readonly Array<PromptArgument>;
  readonly description?: string;
  readonly name: string;
  readonly title?: string;
} {
  constructor(...args: [props: {
    readonly arguments?: readonly Array<{
      readonly description?: string;
      readonly name: string;
      readonly required?: boolean;
      readonly title?: string;
    }>;
    readonly description?: string;
    readonly name: string;
    readonly title?: string;
  }, options?: MakeOptions]);
}

declare class PromptArgument extends {
  readonly description?: string;
  readonly name: string;
  readonly required?: boolean;
  readonly title?: string;
} {
  constructor(_: never);
}

declare class PromptMessage extends {
  readonly content: TextContent | ImageContent | AudioContent | EmbeddedResource | ResourceLink;
  readonly role: "user" | "assistant";
} {
  constructor(_: never);
}

declare class PromptReference extends {
  readonly name: string;
  readonly title?: string;
  readonly type: "ref/prompt";
} {
  constructor(_: never);
}

declare class ReadResourceResult extends {
  readonly _meta?: {
    [key: string]: Json;
  };
  readonly contents: readonly Array<TextResourceContents | BlobResourceContents>;
} {
  constructor(_: never);
}

declare const RequestId: Schema.Union<[typeof Schema.String, typeof Schema.Finite]>;

declare class RequestMeta extends {
  readonly _meta?: {
    readonly progressToken?: string | number;
  };
} {
  constructor(_: never);
}

declare class Resource extends {
  readonly _meta?: {
    [key: string]: Json;
  };
  readonly annotations?: Annotations;
  readonly description?: string;
  readonly mimeType?: string;
  readonly name: string;
  readonly size?: number;
  readonly title?: string;
  readonly uri: string;
} {
  constructor(...args: [props: {
    readonly _meta?: {
      [key: string]: unknown;
    };
    readonly annotations?: {
      readonly audience?: readonly Array<"user" | "assistant">;
      readonly priority?: number;
    };
    readonly description?: string;
    readonly mimeType?: string;
    readonly name: string;
    readonly size?: number;
    readonly title?: string;
    readonly uri: string;
  }, options?: MakeOptions]);
}

declare class ResourceContents extends {
  readonly _meta?: {
    [key: string]: Json;
  };
  readonly mimeType?: string;
  readonly uri: string;
} {
  constructor(_: never);
}

declare class ResourceLink extends {
  readonly _meta?: {
    [key: string]: Json;
  };
  readonly annotations?: Annotations;
  readonly description?: string;
  readonly mimeType?: string;
  readonly name: string;
  readonly size?: number;
  readonly title?: string;
  readonly type: "resource_link";
  readonly uri: string;
} {
  constructor(_: never);
}

declare class ResourceReference extends {
  readonly type: "ref/resource";
  readonly uri: string;
} {
  constructor(_: never);
}

declare class ResourceTemplate extends {
  readonly _meta?: {
    [key: string]: Json;
  };
  readonly annotations?: Annotations;
  readonly description?: string;
  readonly mimeType?: string;
  readonly name: string;
  readonly title?: string;
  readonly uriTemplate: string;
} {
  constructor(...args: [props: {
    readonly _meta?: {
      [key: string]: unknown;
    };
    readonly annotations?: {
      readonly audience?: readonly Array<"user" | "assistant">;
      readonly priority?: number;
    };
    readonly description?: string;
    readonly mimeType?: string;
    readonly name: string;
    readonly title?: string;
    readonly uriTemplate: string;
  }, options?: MakeOptions]);
}

declare class ResultMeta extends {
  readonly _meta?: {
    [key: string]: Json;
  };
} {
  constructor(_: never);
}

declare const Role: Schema.Literals<["user", "assistant"]>;

declare class Root extends {
  readonly name?: string;
  readonly uri: string;
} {
  constructor(...args: [props: {
    readonly name?: string;
    readonly uri: string;
  }, options?: MakeOptions]);
}

declare class SamplingMessage extends {
  readonly content: TextContent | ImageContent | AudioContent;
  readonly role: "user" | "assistant";
} {
  constructor(_: never);
}

declare class ServerCapabilities extends {
  readonly completions?: {};
  readonly experimental?: {
    [key: string]: {};
  };
  readonly extensions?: {
    [key: `${string}/${string}`]: Json;
  };
  readonly logging?: {};
  readonly prompts?: {
    readonly listChanged?: boolean;
  };
  readonly resources?: {
    readonly listChanged?: boolean;
    readonly subscribe?: boolean;
  };
  readonly tools?: {
    readonly listChanged?: boolean;
  };
} {
  constructor(_: never);
}

declare class TextContent extends {
  readonly annotations?: Annotations;
  readonly text: string;
  readonly type: "text";
} {
  constructor(_: never);
}

declare class TextResourceContents extends {
  readonly _meta?: {
    [key: string]: Json;
  };
  readonly mimeType?: string;
  readonly text: string;
  readonly uri: string;
} {
  constructor(_: never);
}

declare class Tool extends {
  readonly _meta?: {
    [key: string]: Json;
  };
  readonly annotations?: ToolAnnotations;
  readonly description?: string;
  readonly inputSchema: any;
  readonly name: string;
  readonly outputSchema?: any;
  readonly title?: string;
} {
  constructor(...args: [props: {
    readonly _meta?: {
      [key: string]: unknown;
    };
    readonly annotations?: {
      readonly destructiveHint?: boolean;
      readonly idempotentHint?: boolean;
      readonly openWorldHint?: boolean;
      readonly readOnlyHint?: boolean;
      readonly title?: string;
    };
    readonly description?: string;
    readonly inputSchema: any;
    readonly name: string;
    readonly outputSchema?: any;
    readonly title?: string;
  }, options?: MakeOptions]);
}

declare class ToolAnnotations extends {
  readonly destructiveHint?: boolean;
  readonly idempotentHint?: boolean;
  readonly openWorldHint?: boolean;
  readonly readOnlyHint?: boolean;
  readonly title?: string;
} {
  constructor(_: never);
}

declare class EnabledWhen extends Shape<
  "effect/unstable/ai/McpSchema/EnabledWhen",
  Predicate<{
    readonly _meta?: {
      readonly progressToken?: string | number;
    };
    readonly capabilities: ClientCapabilities;
    readonly clientInfo: Implementation;
    readonly protocolVersion: string;
  }>,
  this
> {
  constructor(_: never);
}

declare class McpServerClient extends Shape<"effect/ai/McpSchema/McpServerClient", {
  readonly clientId: number;
  readonly getClient: Effect<{
    "elicitation/create": <AsQueue extends boolean = false, Discard = false>(input: {
      readonly message: string;
      readonly requestedSchema: any;
    }, options?: {
      readonly context?: Context<never>;
      readonly discard?: Discard;
      readonly headers?: Input;
    }) => Effect<Discard extends true ? void : ElicitAcceptResult | ElicitDeclineResult, RpcClientError | Discard extends true ? never : ParseError | McpErrorBase | InvalidRequest | MethodNotFound | InvalidParams | InternalError, never>;
    ping: <AsQueue extends boolean = false, Discard = false>(input: {
      readonly _meta?: {
        readonly progressToken?: ... | ... | ...;
      };
    } | undefined, options?: {
      readonly context?: Context<never>;
      readonly discard?: Discard;
      readonly headers?: Input;
    }) => Effect<Discard extends true ? void : {}, RpcClientError | Discard extends true ? never : ParseError | McpErrorBase | InvalidRequest | MethodNotFound | InvalidParams | InternalError, never>;
    "roots/list": <AsQueue extends boolean = false, Discard = false>(input: {
      readonly _meta?: {
        readonly progressToken?: ... | ... | ...;
      };
    } | undefined, options?: {
      readonly context?: Context<never>;
      readonly discard?: Discard;
      readonly headers?: Input;
    }) => Effect<Discard extends true ? void : ListRootsResult, RpcClientError | Discard extends true ? never : ParseError | McpErrorBase | InvalidRequest | MethodNotFound | InvalidParams | InternalError, never>;
    "sampling/createMessage": <AsQueue extends boolean = false, Discard = false>(input: {
      readonly includeContext?: "none" | "thisServer" | "allServers";
      readonly maxTokens: number;
      readonly messages: readonly Array<{
        readonly content: {
          readonly annotations?: ...;
          readonly text: ...;
          readonly type?: ...;
        } | {
          readonly annotations?: ...;
          readonly data: ...;
          readonly mimeType: ...;
          readonly type?: ...;
        } | {
          readonly annotations?: ...;
          readonly data: ...;
          readonly mimeType: ...;
          readonly type?: ...;
        };
        readonly role: "user" | "assistant";
      }>;
      readonly metadata?: {
        [key: string]: unknown;
      };
      readonly modelPreferences?: {
        readonly costPriority?: number;
        readonly hints?: readonly Array<...>;
        readonly intelligencePriority?: number;
        readonly speedPriority?: number;
      };
      readonly stopSequences?: readonly Array<string>;
      readonly systemPrompt?: string;
      readonly temperature?: number;
    }, options?: {
      readonly context?: Context<never>;
      readonly discard?: Discard;
      readonly headers?: Input;
    }) => Effect<Discard extends true ? void : CreateMessageResult, RpcClientError | Discard extends true ? never : ParseError | McpErrorBase | InvalidRequest | MethodNotFound | InvalidParams | InternalError, never>;
  }, never, Scope>;
  readonly initializePayload: {
    readonly _meta?: {
      readonly progressToken?: string | number;
    };
    readonly capabilities: ClientCapabilities;
    readonly clientInfo: Implementation;
    readonly protocolVersion: string;
  };
  readonly protocolVersion: "2025-06-18";
}, this> {
  constructor(_: never);
}