@effect/ai 0.18.12 → 0.18.13

package/dist/dts/McpSchema.d.ts

@@ -0,0 +1,2527 @@
+/**
+ * @since 1.0.0
+ */
+import * as Rpc from "@effect/rpc/Rpc";
+import * as RpcGroup from "@effect/rpc/RpcGroup";
+import * as Schema from "effect/Schema";
+/**
+ * A uniquely identifying ID for a request in JSON-RPC.
+ *
+ * @since 1.0.0
+ * @category Common
+ */
+export declare const RequestId: Schema.Union<[
+    typeof Schema.String,
+    typeof Schema.Number
+]>;
+/**
+ * A uniquely identifying ID for a request in JSON-RPC.
+ *
+ * @since 1.0.0
+ * @category Common
+ */
+export type RequestId = typeof RequestId.Type;
+/**
+ * A progress token, used to associate progress notifications with the original
+ * request.
+ *
+ * @since 1.0.0
+ * @category Common
+ */
+export declare const ProgressToken: Schema.Union<[
+    typeof Schema.String,
+    typeof Schema.Number
+]>;
+/**
+ * A progress token, used to associate progress notifications with the original
+ * request.
+ *
+ * @since 1.0.0
+ * @category Common
+ */
+export type ProgressToken = typeof ProgressToken.Type;
+declare const RequestMeta_base: Schema.Class<RequestMeta, {
+    _meta: Schema.optional<Schema.Struct<{
+        /**
+         * If specified, the caller is requesting out-of-band progress notifications
+         * for this request (as represented by notifications/progress). The value of
+         * this parameter is an opaque token that will be attached to any subsequent
+         * notifications. The receiver is not obligated to provide these
+         * notifications.
+         */
+        progressToken: Schema.optional<Schema.Union<[typeof Schema.String, typeof Schema.Number]>>;
+    }>>;
+}, Schema.Struct.Encoded<{
+    _meta: Schema.optional<Schema.Struct<{
+        /**
+         * If specified, the caller is requesting out-of-band progress notifications
+         * for this request (as represented by notifications/progress). The value of
+         * this parameter is an opaque token that will be attached to any subsequent
+         * notifications. The receiver is not obligated to provide these
+         * notifications.
+         */
+        progressToken: Schema.optional<Schema.Union<[typeof Schema.String, typeof Schema.Number]>>;
+    }>>;
+}>, never, {
+    readonly _meta?: {
+        readonly progressToken?: string | number | undefined;
+    } | undefined;
+}, {}, {}>;
+/**
+ * @since 1.0.0
+ * @category Common
+ */
+export declare class RequestMeta extends RequestMeta_base {
+}
+declare const ResultMeta_base: Schema.Class<ResultMeta, {
+    /**
+     * This result property is reserved by the protocol to allow clients and
+     * servers to attach additional metadata to their responses.
+     */
+    _meta: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+}, Schema.Struct.Encoded<{
+    /**
+     * This result property is reserved by the protocol to allow clients and
+     * servers to attach additional metadata to their responses.
+     */
+    _meta: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+}>, never, {
+    readonly _meta?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+}, {}, {}>;
+/**
+ * @since 1.0.0
+ * @category Common
+ */
+export declare class ResultMeta extends ResultMeta_base {
+}
+declare const NotificationMeta_base: Schema.Class<NotificationMeta, {
+    /**
+     * This parameter name is reserved by MCP to allow clients and servers to
+     * attach additional metadata to their notifications.
+     */
+    _meta: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+}, Schema.Struct.Encoded<{
+    /**
+     * This parameter name is reserved by MCP to allow clients and servers to
+     * attach additional metadata to their notifications.
+     */
+    _meta: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+}>, never, {
+    readonly _meta?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+}, {}, {}>;
+/**
+ * @since 1.0.0
+ * @category Common
+ */
+export declare class NotificationMeta extends NotificationMeta_base {
+}
+/**
+ * An opaque token used to represent a cursor for pagination.
+ *
+ * @since 1.0.0
+ * @category Common
+ */
+export declare const Cursor: typeof Schema.String;
+/**
+ * @since 1.0.0
+ * @category Common
+ */
+export type Cursor = typeof Cursor.Type;
+declare const PaginatedRequestMeta_base: Schema.Class<PaginatedRequestMeta, {
+    /**
+     * An opaque token representing the current pagination position.
+     * If provided, the server should return results starting after this cursor.
+     */
+    cursor: Schema.optional<typeof Schema.String>;
+    _meta: Schema.optional<Schema.Struct<{
+        /**
+         * If specified, the caller is requesting out-of-band progress notifications
+         * for this request (as represented by notifications/progress). The value of
+         * this parameter is an opaque token that will be attached to any subsequent
+         * notifications. The receiver is not obligated to provide these
+         * notifications.
+         */
+        progressToken: Schema.optional<Schema.Union<[typeof Schema.String, typeof Schema.Number]>>;
+    }>>;
+}, Schema.Struct.Encoded<{
+    /**
+     * An opaque token representing the current pagination position.
+     * If provided, the server should return results starting after this cursor.
+     */
+    cursor: Schema.optional<typeof Schema.String>;
+    _meta: Schema.optional<Schema.Struct<{
+        /**
+         * If specified, the caller is requesting out-of-band progress notifications
+         * for this request (as represented by notifications/progress). The value of
+         * this parameter is an opaque token that will be attached to any subsequent
+         * notifications. The receiver is not obligated to provide these
+         * notifications.
+         */
+        progressToken: Schema.optional<Schema.Union<[typeof Schema.String, typeof Schema.Number]>>;
+    }>>;
+}>, never, {
+    readonly _meta?: {
+        readonly progressToken?: string | number | undefined;
+    } | undefined;
+} & {
+    readonly cursor?: string | undefined;
+}, {}, {}>;
+/**
+ * @since 1.0.0
+ * @category Common
+ */
+export declare class PaginatedRequestMeta extends PaginatedRequestMeta_base {
+}
+declare const PaginatedResultMeta_base: Schema.Class<PaginatedResultMeta, {
+    /**
+     * An opaque token representing the pagination position after the last returned result.
+     * If present, there may be more results available.
+     */
+    nextCursor: Schema.optional<typeof Schema.String>;
+    _meta: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+}, Schema.Struct.Encoded<{
+    /**
+     * An opaque token representing the pagination position after the last returned result.
+     * If present, there may be more results available.
+     */
+    nextCursor: Schema.optional<typeof Schema.String>;
+    _meta: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+}>, never, {
+    readonly _meta?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+} & {
+    readonly nextCursor?: string | undefined;
+}, {}, {}>;
+/**
+ * @since 1.0.0
+ * @category Common
+ */
+export declare class PaginatedResultMeta extends PaginatedResultMeta_base {
+}
+/**
+ * The sender or recipient of messages and data in a conversation.
+ * @since 1.0.0
+ * @category Common
+ */
+export declare const Role: Schema.Literal<["user", "assistant"]>;
+/**
+ * @since 1.0.0
+ * @category Common
+ */
+export type Role = typeof Role.Type;
+declare const Annotations_base: Schema.Class<Annotations, {
+    /**
+     * Describes who the intended customer of this object or data is.
+     *
+     * It can include multiple entries to indicate content useful for multiple
+     * audiences (e.g., `["user", "assistant"]`).
+     */
+    audience: Schema.optional<Schema.Array$<Schema.Literal<["user", "assistant"]>>>;
+    /**
+     * Describes how important this data is for operating the server.
+     *
+     * A value of 1 means "most important," and indicates that the data is
+     * effectively required, while 0 means "least important," and indicates that
+     * the data is entirely optional.
+     */
+    priority: Schema.optional<Schema.filter<typeof Schema.Number>>;
+}, Schema.Struct.Encoded<{
+    /**
+     * Describes who the intended customer of this object or data is.
+     *
+     * It can include multiple entries to indicate content useful for multiple
+     * audiences (e.g., `["user", "assistant"]`).
+     */
+    audience: Schema.optional<Schema.Array$<Schema.Literal<["user", "assistant"]>>>;
+    /**
+     * Describes how important this data is for operating the server.
+     *
+     * A value of 1 means "most important," and indicates that the data is
+     * effectively required, while 0 means "least important," and indicates that
+     * the data is entirely optional.
+     */
+    priority: Schema.optional<Schema.filter<typeof Schema.Number>>;
+}>, never, {
+    readonly audience?: readonly ("user" | "assistant")[] | undefined;
+} & {
+    readonly priority?: number | undefined;
+}, {}, {}>;
+/**
+ * Optional annotations for the client. The client can use annotations to
+ * inform how objects are used or displayed
+ *
+ * @since 1.0.0
+ * @category Common
+ */
+export declare class Annotations extends Annotations_base {
+}
+declare const Implementation_base: Schema.Class<Implementation, {
+    name: typeof Schema.String;
+    version: typeof Schema.String;
+}, Schema.Struct.Encoded<{
+    name: typeof Schema.String;
+    version: typeof Schema.String;
+}>, never, {
+    readonly name: string;
+} & {
+    readonly version: string;
+}, {}, {}>;
+/**
+ * Describes the name and version of an MCP implementation.
+ *
+ * @since 1.0.0
+ * @category Common
+ */
+export declare class Implementation extends Implementation_base {
+}
+declare const ClientCapabilities_base: Schema.Class<ClientCapabilities, {
+    /**
+     * Experimental, non-standard capabilities that the client supports.
+     */
+    experimental: Schema.optional<Schema.Record$<typeof Schema.String, Schema.Struct<{}>>>;
+    /**
+     * Present if the client supports listing roots.
+     */
+    roots: Schema.optional<Schema.Struct<{
+        /**
+         * Whether the client supports notifications for changes to the roots list.
+         */
+        listChanged: Schema.optional<typeof Schema.Boolean>;
+    }>>;
+    /**
+     * Present if the client supports sampling from an LLM.
+     */
+    sampling: Schema.optional<Schema.Struct<{}>>;
+}, Schema.Struct.Encoded<{
+    /**
+     * Experimental, non-standard capabilities that the client supports.
+     */
+    experimental: Schema.optional<Schema.Record$<typeof Schema.String, Schema.Struct<{}>>>;
+    /**
+     * Present if the client supports listing roots.
+     */
+    roots: Schema.optional<Schema.Struct<{
+        /**
+         * Whether the client supports notifications for changes to the roots list.
+         */
+        listChanged: Schema.optional<typeof Schema.Boolean>;
+    }>>;
+    /**
+     * Present if the client supports sampling from an LLM.
+     */
+    sampling: Schema.optional<Schema.Struct<{}>>;
+}>, never, {
+    readonly experimental?: {
+        readonly [x: string]: {};
+    } | undefined;
+} & {
+    readonly roots?: {
+        readonly listChanged?: boolean | undefined;
+    } | undefined;
+} & {
+    readonly sampling?: {} | undefined;
+}, {}, {}>;
+/**
+ * Capabilities a client may support. Known capabilities are defined here, in
+ * this schema, but this is not a closed set: any client can define its own,
+ * additional capabilities.
+ *
+ * @since 1.0.0
+ * @category Common
+ */
+export declare class ClientCapabilities extends ClientCapabilities_base {
+}
+declare const ServerCapabilities_base: Schema.Class<ServerCapabilities, {
+    /**
+     * Experimental, non-standard capabilities that the server supports.
+     */
+    experimental: Schema.optional<Schema.Record$<typeof Schema.String, Schema.Struct<{}>>>;
+    /**
+     * Present if the server supports sending log messages to the client.
+     */
+    logging: Schema.optional<Schema.Struct<{}>>;
+    /**
+     * Present if the server supports argument autocompletion suggestions.
+     */
+    completions: Schema.optional<Schema.Struct<{}>>;
+    /**
+     * Present if the server offers any prompt templates.
+     */
+    prompts: Schema.optional<Schema.Struct<{
+        /**
+         * Whether this server supports notifications for changes to the prompt list.
+         */
+        listChanged: Schema.optional<typeof Schema.Boolean>;
+    }>>;
+    /**
+     * Present if the server offers any resources to read.
+     */
+    resources: Schema.optional<Schema.Struct<{
+        /**
+         * Whether this server supports subscribing to resource updates.
+         */
+        subscribe: Schema.optional<typeof Schema.Boolean>;
+        /**
+         * Whether this server supports notifications for changes to the resource list.
+         */
+        listChanged: Schema.optional<typeof Schema.Boolean>;
+    }>>;
+    /**
+     * Present if the server offers any tools to call.
+     */
+    tools: Schema.optional<Schema.Struct<{
+        /**
+         * Whether this server supports notifications for changes to the tool list.
+         */
+        listChanged: Schema.optional<typeof Schema.Boolean>;
+    }>>;
+}, Schema.Struct.Encoded<{
+    /**
+     * Experimental, non-standard capabilities that the server supports.
+     */
+    experimental: Schema.optional<Schema.Record$<typeof Schema.String, Schema.Struct<{}>>>;
+    /**
+     * Present if the server supports sending log messages to the client.
+     */
+    logging: Schema.optional<Schema.Struct<{}>>;
+    /**
+     * Present if the server supports argument autocompletion suggestions.
+     */
+    completions: Schema.optional<Schema.Struct<{}>>;
+    /**
+     * Present if the server offers any prompt templates.
+     */
+    prompts: Schema.optional<Schema.Struct<{
+        /**
+         * Whether this server supports notifications for changes to the prompt list.
+         */
+        listChanged: Schema.optional<typeof Schema.Boolean>;
+    }>>;
+    /**
+     * Present if the server offers any resources to read.
+     */
+    resources: Schema.optional<Schema.Struct<{
+        /**
+         * Whether this server supports subscribing to resource updates.
+         */
+        subscribe: Schema.optional<typeof Schema.Boolean>;
+        /**
+         * Whether this server supports notifications for changes to the resource list.
+         */
+        listChanged: Schema.optional<typeof Schema.Boolean>;
+    }>>;
+    /**
+     * Present if the server offers any tools to call.
+     */
+    tools: Schema.optional<Schema.Struct<{
+        /**
+         * Whether this server supports notifications for changes to the tool list.
+         */
+        listChanged: Schema.optional<typeof Schema.Boolean>;
+    }>>;
+}>, never, {
+    readonly tools?: {
+        readonly listChanged?: boolean | undefined;
+    } | undefined;
+} & {
+    readonly experimental?: {
+        readonly [x: string]: {};
+    } | undefined;
+} & {
+    readonly logging?: {} | undefined;
+} & {
+    readonly completions?: {} | undefined;
+} & {
+    readonly prompts?: {
+        readonly listChanged?: boolean | undefined;
+    } | undefined;
+} & {
+    readonly resources?: {
+        readonly listChanged?: boolean | undefined;
+        readonly subscribe?: boolean | undefined;
+    } | undefined;
+}, {}, {}>;
+/**
+ * Capabilities that a server may support. Known capabilities are defined
+ * here, in this schema, but this is not a closed set: any server can define
+ * its own, additional capabilities.
+ *
+ * @since 1.0.0
+ * @category Common
+ */
+export declare class ServerCapabilities extends ServerCapabilities_base {
+}
+declare const McpError_base: Schema.Class<McpError, {
+    /**
+     * The error type that occurred.
+     */
+    code: typeof Schema.Number;
+    /**
+     * A short description of the error. The message SHOULD be limited to a
+     * concise single sentence.
+     */
+    message: typeof Schema.String;
+    /**
+     * Additional information about the error. The value of this member is
+     * defined by the sender (e.g. detailed error information, nested errors etc.).
+     */
+    data: Schema.optional<typeof Schema.Unknown>;
+}, Schema.Struct.Encoded<{
+    /**
+     * The error type that occurred.
+     */
+    code: typeof Schema.Number;
+    /**
+     * A short description of the error. The message SHOULD be limited to a
+     * concise single sentence.
+     */
+    message: typeof Schema.String;
+    /**
+     * Additional information about the error. The value of this member is
+     * defined by the sender (e.g. detailed error information, nested errors etc.).
+     */
+    data: Schema.optional<typeof Schema.Unknown>;
+}>, never, {
+    readonly data?: unknown;
+} & {
+    readonly code: number;
+} & {
+    readonly message: string;
+}, {}, {}>;
+/**
+ * @since 1.0.0
+ * @category Errors
+ */
+export declare class McpError extends McpError_base {
+}
+/**
+ * @since 1.0.0
+ * @category Errors
+ */
+export declare const INVALID_REQUEST_ERROR_CODE: -32600;
+/**
+ * @since 1.0.0
+ * @category Errors
+ */
+export declare const METHOD_NOT_FOUND_ERROR_CODE: -32601;
+/**
+ * @since 1.0.0
+ * @category Errors
+ */
+export declare const INVALID_PARAMS_ERROR_CODE: -32602;
+/**
+ * @since 1.0.0
+ * @category Errors
+ */
+export declare const INTERNAL_ERROR_CODE: -32603;
+/**
+ * @since 1.0.0
+ * @category Errors
+ */
+export declare const PARSE_ERROR_CODE: -32700;
+declare const ParseError_base: Schema.TaggedErrorClass<ParseError, "ParseError", {
+    readonly _tag: Schema.tag<"ParseError">;
+} & {
+    code: Schema.tag<-32700>;
+    message: typeof Schema.String;
+    data: Schema.optional<typeof Schema.Unknown>;
+}>;
+/**
+ * @since 1.0.0
+ * @category Errors
+ */
+export declare class ParseError extends ParseError_base {
+}
+declare const InvalidRequest_base: Schema.TaggedErrorClass<InvalidRequest, "InvalidRequest", {
+    readonly _tag: Schema.tag<"InvalidRequest">;
+} & {
+    code: Schema.tag<-32600>;
+    message: typeof Schema.String;
+    data: Schema.optional<typeof Schema.Unknown>;
+}>;
+/**
+ * @since 1.0.0
+ * @category Errors
+ */
+export declare class InvalidRequest extends InvalidRequest_base {
+}
+declare const MethodNotFound_base: Schema.TaggedErrorClass<MethodNotFound, "MethodNotFound", {
+    readonly _tag: Schema.tag<"MethodNotFound">;
+} & {
+    code: Schema.tag<-32601>;
+    message: typeof Schema.String;
+    data: Schema.optional<typeof Schema.Unknown>;
+}>;
+/**
+ * @since 1.0.0
+ * @category Errors
+ */
+export declare class MethodNotFound extends MethodNotFound_base {
+}
+declare const InvalidParams_base: Schema.TaggedErrorClass<InvalidParams, "InvalidParams", {
+    readonly _tag: Schema.tag<"InvalidParams">;
+} & {
+    code: Schema.tag<-32602>;
+    message: typeof Schema.String;
+    data: Schema.optional<typeof Schema.Unknown>;
+}>;
+/**
+ * @since 1.0.0
+ * @category Errors
+ */
+export declare class InvalidParams extends InvalidParams_base {
+}
+declare const InternalError_base: Schema.TaggedErrorClass<InternalError, "InternalError", {
+    readonly _tag: Schema.tag<"InternalError">;
+} & {
+    code: Schema.tag<-32603>;
+    message: typeof Schema.String;
+    data: Schema.optional<typeof Schema.Unknown>;
+}>;
+/**
+ * @since 1.0.0
+ * @category Errors
+ */
+export declare class InternalError extends InternalError_base {
+    static readonly notImplemented: InternalError;
+}
+declare const Ping_base: Rpc.Rpc<"ping", typeof RequestMeta, Schema.Struct<{}>, typeof McpError, never>;
+/**
+ * A ping, issued by either the server or the client, to check that the other
+ * party is still alive. The receiver must promptly respond, or else may be
+ * disconnected.
+ *
+ * @since 1.0.0
+ * @category Ping
+ */
+export declare class Ping extends Ping_base {
+}
+declare const InitializeResult_base: Schema.Class<InitializeResult, {
+    /**
+     * The version of the Model Context Protocol that the server wants to use.
+     * This may not match the version that the client requested. If the client
+     * cannot support this version, it MUST disconnect.
+     */
+    protocolVersion: typeof Schema.String;
+    capabilities: typeof ServerCapabilities;
+    serverInfo: typeof Implementation;
+    /**
+     * Instructions describing how to use the server and its features.
+     *
+     * This can be used by clients to improve the LLM's understanding of available
+     * tools, resources, etc. It can be thought of like a "hint" to the model.
+     * For example, this information MAY be added to the system prompt.
+     */
+    instructions: Schema.optional<typeof Schema.String>;
+    _meta: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+}, Schema.Struct.Encoded<{
+    /**
+     * The version of the Model Context Protocol that the server wants to use.
+     * This may not match the version that the client requested. If the client
+     * cannot support this version, it MUST disconnect.
+     */
+    protocolVersion: typeof Schema.String;
+    capabilities: typeof ServerCapabilities;
+    serverInfo: typeof Implementation;
+    /**
+     * Instructions describing how to use the server and its features.
+     *
+     * This can be used by clients to improve the LLM's understanding of available
+     * tools, resources, etc. It can be thought of like a "hint" to the model.
+     * For example, this information MAY be added to the system prompt.
+     */
+    instructions: Schema.optional<typeof Schema.String>;
+    _meta: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+}>, never, {
+    readonly _meta?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+} & {
+    readonly protocolVersion: string;
+} & {
+    readonly capabilities: ServerCapabilities;
+} & {
+    readonly serverInfo: Implementation;
+} & {
+    readonly instructions?: string | undefined;
+}, {}, {}>;
+/**
+ * After receiving an initialize request from the client, the server sends this
+ * response.
+ *
+ * @since 1.0.0
+ * @category Initialization
+ */
+export declare class InitializeResult extends InitializeResult_base {
+}
+declare const Initialize_base: Rpc.Rpc<"initialize", Schema.Struct<{
+    /**
+     * The latest version of the Model Context Protocol that the client
+     * supports. The client MAY decide to support older versions as well.
+     */
+    protocolVersion: typeof Schema.String;
+    /**
+     * Capabilities a client may support. Known capabilities are defined here,
+     * in this schema, but this is not a closed set: any client can define its
+     * own, additional capabilities.
+     */
+    capabilities: typeof ClientCapabilities;
+    /**
+     * Describes the name and version of an MCP implementation.
+     */
+    clientInfo: typeof Implementation;
+    _meta: Schema.optional<Schema.Struct<{
+        /**
+         * If specified, the caller is requesting out-of-band progress notifications
+         * for this request (as represented by notifications/progress). The value of
+         * this parameter is an opaque token that will be attached to any subsequent
+         * notifications. The receiver is not obligated to provide these
+         * notifications.
+         */
+        progressToken: Schema.optional<Schema.Union<[typeof Schema.String, typeof Schema.Number]>>;
+    }>>;
+}>, typeof InitializeResult, typeof McpError, never>;
+/**
+ * This request is sent from the client to the server when it first connects,
+ * asking it to begin initialization.
+ *
+ * @since 1.0.0
+ * @category Initialization
+ */
+export declare class Initialize extends Initialize_base {
+}
+declare const InitializedNotification_base: Rpc.Rpc<"notifications/initialized", typeof NotificationMeta, typeof Schema.Void, typeof Schema.Never, never>;
+/**
+ * This notification is sent from the client to the server after initialization
+ * has finished.
+ *
+ * @since 1.0.0
+ * @category Initialization
+ */
+export declare class InitializedNotification extends InitializedNotification_base {
+}
+declare const CancelledNotification_base: Rpc.Rpc<"notifications/cancelled", Schema.Struct<{
+    /**
+     * The ID of the request to cancel.
+     *
+     * This MUST correspond to the ID of a request previously issued in the
+     * same direction.
+     */
+    requestId: Schema.Union<[typeof Schema.String, typeof Schema.Number]>;
+    /**
+     * An optional string describing the reason for the cancellation. This MAY
+     * be logged or presented to the user.
+     */
+    reason: Schema.optional<typeof Schema.String>;
+    _meta: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+}>, typeof Schema.Void, typeof Schema.Never, never>;
+/**
+ * @since 1.0.0
+ * @category Cancellation
+ */
+export declare class CancelledNotification extends CancelledNotification_base {
+}
+declare const ProgressNotification_base: Rpc.Rpc<"notifications/progress", Schema.Struct<{
+    /**
+     * The progress token which was given in the initial request, used to
+     * associate this notification with the request that is proceeding.
+     */
+    progressToken: Schema.Union<[typeof Schema.String, typeof Schema.Number]>;
+    /**
+     * The progress thus far. This should increase every time progress is made,
+     * even if the total is unknown.
+     */
+    progress: Schema.optional<typeof Schema.Number>;
+    /**
+     * Total number of items to process (or total progress required), if known.
+     */
+    total: Schema.optional<typeof Schema.Number>;
+    /**
+     * An optional message describing the current progress.
+     */
+    message: Schema.optional<typeof Schema.String>;
+    _meta: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+}>, typeof Schema.Void, typeof Schema.Never, never>;
+/**
+ * An out-of-band notification used to inform the receiver of a progress update
+ * for a long-running request.
+ *
+ * @since 1.0.0
+ * @category Progress
+ */
+export declare class ProgressNotification extends ProgressNotification_base {
+}
+declare const Resource_base: Schema.Class<Resource, {
+    /**
+     * The URI of this resource.
+     */
+    uri: typeof Schema.String;
+    /**
+     * A human-readable name for this resource.
+     *
+     * This can be used by clients to populate UI elements.
+     */
+    name: typeof Schema.String;
+    /**
+     * A description of what this resource represents.
+     *
+     * This can be used by clients to improve the LLM's understanding of available
+     * resources. It can be thought of like a "hint" to the model.
+     */
+    description: Schema.optional<typeof Schema.String>;
+    /**
+     * The MIME type of this resource, if known.
+     */
+    mimeType: Schema.optional<typeof Schema.String>;
+    /**
+     * Optional annotations for the client.
+     */
+    annotations: Schema.optional<typeof Annotations>;
+    /**
+     * The size of the raw resource content, in bytes (i.e., before base64
+     * encoding or any tokenization), if known.
+     *
+     * This can be used by Hosts to display file sizes and estimate context
+     * window usage.
+     */
+    size: Schema.optional<typeof Schema.Number>;
+}, Schema.Struct.Encoded<{
+    /**
+     * The URI of this resource.
+     */
+    uri: typeof Schema.String;
+    /**
+     * A human-readable name for this resource.
+     *
+     * This can be used by clients to populate UI elements.
+     */
+    name: typeof Schema.String;
+    /**
+     * A description of what this resource represents.
+     *
+     * This can be used by clients to improve the LLM's understanding of available
+     * resources. It can be thought of like a "hint" to the model.
+     */
+    description: Schema.optional<typeof Schema.String>;
+    /**
+     * The MIME type of this resource, if known.
+     */
+    mimeType: Schema.optional<typeof Schema.String>;
+    /**
+     * Optional annotations for the client.
+     */
+    annotations: Schema.optional<typeof Annotations>;
+    /**
+     * The size of the raw resource content, in bytes (i.e., before base64
+     * encoding or any tokenization), if known.
+     *
+     * This can be used by Hosts to display file sizes and estimate context
+     * window usage.
+     */
+    size: Schema.optional<typeof Schema.Number>;
+}>, never, {
+    readonly description?: string | undefined;
+} & {
+    readonly annotations?: Annotations | undefined;
+} & {
+    readonly name: string;
+} & {
+    readonly uri: string;
+} & {
+    readonly mimeType?: string | undefined;
+} & {
+    readonly size?: number | undefined;
+}, {}, {}>;
+/**
+ * A known resource that the server is capable of reading.
+ *
+ * @since 1.0.0
+ * @category Resources
+ */
+export declare class Resource extends Resource_base {
+}
+declare const ResourceTemplate_base: Schema.Class<ResourceTemplate, {
+    /**
+     * A URI template (according to RFC 6570) that can be used to construct
+     * resource URIs.
+     */
+    uriTemplate: typeof Schema.String;
+    /**
+     * A human-readable name for the type of resource this template refers to.
+     *
+     * This can be used by clients to populate UI elements.
+     */
+    name: typeof Schema.String;
+    /**
+     * A description of what this template is for.
+     *
+     * This can be used by clients to improve the LLM's understanding of available
+     * resources. It can be thought of like a "hint" to the model.
+     */
+    description: Schema.optional<typeof Schema.String>;
+    /**
+     * The MIME type for all resources that match this template. This should only
+     * be included if all resources matching this template have the same type.
+     */
+    mimeType: Schema.optional<typeof Schema.String>;
+    /**
+     * Optional annotations for the client.
+     */
+    annotations: Schema.optional<typeof Annotations>;
+}, Schema.Struct.Encoded<{
+    /**
+     * A URI template (according to RFC 6570) that can be used to construct
+     * resource URIs.
+     */
+    uriTemplate: typeof Schema.String;
+    /**
+     * A human-readable name for the type of resource this template refers to.
+     *
+     * This can be used by clients to populate UI elements.
+     */
+    name: typeof Schema.String;
+    /**
+     * A description of what this template is for.
+     *
+     * This can be used by clients to improve the LLM's understanding of available
+     * resources. It can be thought of like a "hint" to the model.
+     */
+    description: Schema.optional<typeof Schema.String>;
+    /**
+     * The MIME type for all resources that match this template. This should only
+     * be included if all resources matching this template have the same type.
+     */
+    mimeType: Schema.optional<typeof Schema.String>;
+    /**
+     * Optional annotations for the client.
+     */
+    annotations: Schema.optional<typeof Annotations>;
+}>, never, {
+    readonly description?: string | undefined;
+} & {
+    readonly annotations?: Annotations | undefined;
+} & {
+    readonly name: string;
+} & {
+    readonly mimeType?: string | undefined;
+} & {
+    readonly uriTemplate: string;
+}, {}, {}>;
+/**
+ * A template description for resources available on the server.
+ *
+ * @since 1.0.0
+ * @category Resources
+ */
+export declare class ResourceTemplate extends ResourceTemplate_base {
+}
+declare const ResourceContents_base: Schema.Class<ResourceContents, {
+    /**
+     * The URI of this resource.
+     */
+    uri: typeof Schema.String;
+    /**
+     * The MIME type of this resource, if known.
+     */
+    mimeType: Schema.optional<typeof Schema.String>;
+}, Schema.Struct.Encoded<{
+    /**
+     * The URI of this resource.
+     */
+    uri: typeof Schema.String;
+    /**
+     * The MIME type of this resource, if known.
+     */
+    mimeType: Schema.optional<typeof Schema.String>;
+}>, never, {
+    readonly uri: string;
+} & {
+    readonly mimeType?: string | undefined;
+}, {}, {}>;
+/**
+ * The contents of a specific resource or sub-resource.
+ *
+ * @since 1.0.0
+ * @category Resources
+ */
+export declare class ResourceContents extends ResourceContents_base {
+}
+declare const TextResourceContents_base: Schema.Class<TextResourceContents, {
+    /**
+     * The URI of this resource.
+     */
+    uri: typeof Schema.String;
+    /**
+     * The MIME type of this resource, if known.
+     */
+    mimeType: Schema.optional<typeof Schema.String>;
+} & {
+    /**
+     * The text of the item. This must only be set if the item can actually be
+     * represented as text (not binary data).
+     */
+    text: typeof Schema.String;
+}, {
+    readonly uri: string;
+} & {
+    readonly mimeType?: string | undefined;
+} & {
+    readonly text: string;
+} & {}, never, {
+    readonly uri: string;
+} & {
+    readonly mimeType?: string | undefined;
+} & {
+    readonly text: string;
+}, ResourceContents, {}>;
+/**
+ * The contents of a text resource, which can be represented as a string.
+ *
+ * @since 1.0.0
+ * @category Resources
+ */
+export declare class TextResourceContents extends TextResourceContents_base {
+}
+declare const BlobResourceContents_base: Schema.Class<BlobResourceContents, {
+    /**
+     * The URI of this resource.
+     */
+    uri: typeof Schema.String;
+    /**
+     * The MIME type of this resource, if known.
+     */
+    mimeType: Schema.optional<typeof Schema.String>;
+} & {
+    /**
+     * The binary data of the item decoded from a base64-encoded string.
+     */
+    blob: Schema.Schema<Uint8Array<ArrayBufferLike>, string, never>;
+}, {
+    readonly uri: string;
+} & {
+    readonly mimeType?: string | undefined;
+} & {
+    readonly blob: string;
+} & {}, never, {
+    readonly uri: string;
+} & {
+    readonly mimeType?: string | undefined;
+} & {
+    readonly blob: Uint8Array<ArrayBufferLike>;
+}, ResourceContents, {}>;
+/**
+ * The contents of a binary resource, which can be represented as an Uint8Array
+ *
+ * @since 1.0.0
+ * @category Resources
+ */
+export declare class BlobResourceContents extends BlobResourceContents_base {
+}
+declare const ListResourcesResult_base: Schema.Class<ListResourcesResult, {
+    resources: Schema.Array$<typeof Resource>;
+    nextCursor: Schema.optional<typeof Schema.String>;
+    _meta: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+}, Schema.Struct.Encoded<{
+    resources: Schema.Array$<typeof Resource>;
+    nextCursor: Schema.optional<typeof Schema.String>;
+    _meta: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+}>, never, {
+    readonly _meta?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+} & {
+    readonly nextCursor?: string | undefined;
+} & {
+    readonly resources: readonly Resource[];
+}, {}, {}>;
+/**
+ * The server's response to a resources/list request from the client.
+ *
+ * @since 1.0.0
+ * @category Resources
+ */
+export declare class ListResourcesResult extends ListResourcesResult_base {
+}
+declare const ListResources_base: Rpc.Rpc<"resources/list", typeof PaginatedRequestMeta, typeof ListResourcesResult, typeof McpError, never>;
+/**
+ * Sent from the client to request a list of resources the server has.
+ *
+ * @since 1.0.0
+ * @category Resources
+ */
+export declare class ListResources extends ListResources_base {
+}
+declare const ListResourceTemplatesResult_base: Schema.Class<ListResourceTemplatesResult, {
+    resourceTemplates: Schema.Array$<typeof ResourceTemplate>;
+    nextCursor: Schema.optional<typeof Schema.String>;
+    _meta: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+}, Schema.Struct.Encoded<{
+    resourceTemplates: Schema.Array$<typeof ResourceTemplate>;
+    nextCursor: Schema.optional<typeof Schema.String>;
+    _meta: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+}>, never, {
+    readonly _meta?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+} & {
+    readonly nextCursor?: string | undefined;
+} & {
+    readonly resourceTemplates: readonly ResourceTemplate[];
+}, {}, {}>;
+/**
+ * The server's response to a resources/templates/list request from the client.
+ *
+ * @since 1.0.0
+ * @category Resources
+ */
+export declare class ListResourceTemplatesResult extends ListResourceTemplatesResult_base {
+}
+declare const ListResourceTemplates_base: Rpc.Rpc<"resources/templates/list", typeof PaginatedRequestMeta, typeof ListResourceTemplatesResult, typeof McpError, never>;
+/**
+ * Sent from the client to request a list of resource templates the server has.
+ *
+ * @since 1.0.0
+ * @category Resources
+ */
+export declare class ListResourceTemplates extends ListResourceTemplates_base {
+}
+declare const ReadResourceResult_base: Schema.Class<ReadResourceResult, {
+    contents: Schema.Array$<Schema.Union<[typeof TextResourceContents, typeof BlobResourceContents]>>;
+    _meta: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+}, Schema.Struct.Encoded<{
+    contents: Schema.Array$<Schema.Union<[typeof TextResourceContents, typeof BlobResourceContents]>>;
+    _meta: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+}>, never, {
+    readonly _meta?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+} & {
+    readonly contents: readonly (TextResourceContents | BlobResourceContents)[];
+}, {}, {}>;
+/**
+ * The server's response to a resources/read request from the client.
+ *
+ * @since 1.0.0
+ * @category Resources
+ */
+export declare class ReadResourceResult extends ReadResourceResult_base {
+}
+declare const ReadResource_base: Rpc.Rpc<"resources/read", Schema.Struct<{
+    /**
+     * The URI of the resource to read. The URI can use any protocol; it is up
+     * to the server how to interpret it.
+     */
+    uri: typeof Schema.String;
+    _meta: Schema.optional<Schema.Struct<{
+        /**
+         * If specified, the caller is requesting out-of-band progress notifications
+         * for this request (as represented by notifications/progress). The value of
+         * this parameter is an opaque token that will be attached to any subsequent
+         * notifications. The receiver is not obligated to provide these
+         * notifications.
+         */
+        progressToken: Schema.optional<Schema.Union<[typeof Schema.String, typeof Schema.Number]>>;
+    }>>;
+}>, typeof ReadResourceResult, typeof McpError, never>;
+/**
+ * Sent from the client to the server, to read a specific resource URI.
+ *
+ * @since 1.0.0
+ * @category Resources
+ */
+export declare class ReadResource extends ReadResource_base {
+}
+declare const ResourceListChangedNotification_base: Rpc.Rpc<"notifications/resources/list_changed", typeof NotificationMeta, typeof Schema.Void, typeof Schema.Never, never>;
+/**
+ * An optional notification from the server to the client, informing it that the
+ * list of resources it can read from has changed. This may be issued by servers
+ * without any previous subscription from the client.
+ *
+ * @since 1.0.0
+ * @category Resources
+ */
+export declare class ResourceListChangedNotification extends ResourceListChangedNotification_base {
+}
+declare const Subscribe_base: Rpc.Rpc<"resources/subscribe", Schema.Struct<{
+    /**
+     * The URI of the resource to subscribe to. The URI can use any protocol;
+     * it is up to the server how to interpret it.
+     */
+    uri: typeof Schema.String;
+    _meta: Schema.optional<Schema.Struct<{
+        /**
+         * If specified, the caller is requesting out-of-band progress notifications
+         * for this request (as represented by notifications/progress). The value of
+         * this parameter is an opaque token that will be attached to any subsequent
+         * notifications. The receiver is not obligated to provide these
+         * notifications.
+         */
+        progressToken: Schema.optional<Schema.Union<[typeof Schema.String, typeof Schema.Number]>>;
+    }>>;
+}>, typeof Schema.Void, typeof McpError, never>;
+/**
+ * Sent from the client to request resources/updated notifications from the
+ * server whenever a particular resource changes.
+ *
+ * @since 1.0.0
+ * @category Resources
+ */
+export declare class Subscribe extends Subscribe_base {
+}
+declare const Unsubscribe_base: Rpc.Rpc<"resources/unsubscribe", Schema.Struct<{
+    /**
+     * The URI of the resource to subscribe to. The URI can use any protocol;
+     * it is up to the server how to interpret it.
+     */
+    uri: typeof Schema.String;
+    _meta: Schema.optional<Schema.Struct<{
+        /**
+         * If specified, the caller is requesting out-of-band progress notifications
+         * for this request (as represented by notifications/progress). The value of
+         * this parameter is an opaque token that will be attached to any subsequent
+         * notifications. The receiver is not obligated to provide these
+         * notifications.
+         */
+        progressToken: Schema.optional<Schema.Union<[typeof Schema.String, typeof Schema.Number]>>;
+    }>>;
+}>, typeof Schema.Void, typeof McpError, never>;
+/**
+ * Sent from the client to request cancellation of resources/updated
+ * notifications from the server. This should follow a previous
+ * resources/subscribe request.
+ *
+ * @since 1.0.0
+ * @category Resources
+ */
+export declare class Unsubscribe extends Unsubscribe_base {
+}
+declare const ResourceUpdatedNotification_base: Rpc.Rpc<"notifications/resources/updated", Schema.Struct<{
+    /**
+     * The URI of the resource that has been updated. This might be a sub-resource of the one that the client actually subscribed to.
+     */
+    uri: typeof Schema.String;
+    _meta: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+}>, typeof Schema.Void, typeof Schema.Never, never>;
+/**
+ * @since 1.0.0
+ * @category Resources
+ */
+export declare class ResourceUpdatedNotification extends ResourceUpdatedNotification_base {
+}
+declare const PromptArgument_base: Schema.Class<PromptArgument, {
+    /**
+     * The name of the argument.
+     */
+    name: typeof Schema.String;
+    /**
+     * A human-readable description of the argument.
+     */
+    description: Schema.optional<typeof Schema.String>;
+    /**
+     * Whether this argument must be provided.
+     */
+    required: Schema.optional<typeof Schema.Boolean>;
+}, Schema.Struct.Encoded<{
+    /**
+     * The name of the argument.
+     */
+    name: typeof Schema.String;
+    /**
+     * A human-readable description of the argument.
+     */
+    description: Schema.optional<typeof Schema.String>;
+    /**
+     * Whether this argument must be provided.
+     */
+    required: Schema.optional<typeof Schema.Boolean>;
+}>, never, {
+    readonly description?: string | undefined;
+} & {
+    readonly name: string;
+} & {
+    readonly required?: boolean | undefined;
+}, {}, {}>;
+/**
+ * Describes an argument that a prompt can accept.
+ *
+ * @since 1.0.0
+ * @category Prompts
+ */
+export declare class PromptArgument extends PromptArgument_base {
+}
+declare const Prompt_base: Schema.Class<Prompt, {
+    /**
+     * The name of the prompt or prompt template.
+     */
+    name: typeof Schema.String;
+    /**
+     * An optional description of what this prompt provides
+     */
+    description: Schema.optional<typeof Schema.String>;
+    /**
+     * A list of arguments to use for templating the prompt.
+     */
+    arguments: Schema.optional<Schema.Array$<typeof PromptArgument>>;
+}, Schema.Struct.Encoded<{
+    /**
+     * The name of the prompt or prompt template.
+     */
+    name: typeof Schema.String;
+    /**
+     * An optional description of what this prompt provides
+     */
+    description: Schema.optional<typeof Schema.String>;
+    /**
+     * A list of arguments to use for templating the prompt.
+     */
+    arguments: Schema.optional<Schema.Array$<typeof PromptArgument>>;
+}>, never, {
+    readonly description?: string | undefined;
+} & {
+    readonly name: string;
+} & {
+    readonly arguments?: readonly PromptArgument[] | undefined;
+}, {}, {}>;
+/**
+ * A prompt or prompt template that the server offers.
+ *
+ * @since 1.0.0
+ * @category Prompts
+ */
+export declare class Prompt extends Prompt_base {
+}
+declare const TextContent_base: Schema.Class<TextContent, {
+    type: Schema.tag<"text">;
+    /**
+     * The text content of the message.
+     */
+    text: typeof Schema.String;
+    /**
+     * Optional annotations for the client.
+     */
+    annotations: Schema.optional<typeof Annotations>;
+}, Schema.Struct.Encoded<{
+    type: Schema.tag<"text">;
+    /**
+     * The text content of the message.
+     */
+    text: typeof Schema.String;
+    /**
+     * Optional annotations for the client.
+     */
+    annotations: Schema.optional<typeof Annotations>;
+}>, never, {
+    readonly annotations?: Annotations | undefined;
+} & {
+    readonly text: string;
+} & {
+    readonly type?: "text" | undefined;
+}, {}, {}>;
+/**
+ * Text provided to or from an LLM.
+ *
+ * @since 1.0.0
+ * @category Prompts
+ */
+export declare class TextContent extends TextContent_base {
+}
+declare const ImageContent_base: Schema.Class<ImageContent, {
+    type: Schema.tag<"image">;
+    /**
+     * The image data.
+     */
+    data: Schema.Schema<Uint8Array<ArrayBufferLike>, string, never>;
+    /**
+     * The MIME type of the image. Different providers may support different
+     * image types.
+     */
+    mimeType: typeof Schema.String;
+    /**
+     * Optional annotations for the client.
+     */
+    annotations: Schema.optional<typeof Annotations>;
+}, Schema.Struct.Encoded<{
+    type: Schema.tag<"image">;
+    /**
+     * The image data.
+     */
+    data: Schema.Schema<Uint8Array<ArrayBufferLike>, string, never>;
+    /**
+     * The MIME type of the image. Different providers may support different
+     * image types.
+     */
+    mimeType: typeof Schema.String;
+    /**
+     * Optional annotations for the client.
+     */
+    annotations: Schema.optional<typeof Annotations>;
+}>, never, {
+    readonly annotations?: Annotations | undefined;
+} & {
+    readonly type?: "image" | undefined;
+} & {
+    readonly data: Uint8Array<ArrayBufferLike>;
+} & {
+    readonly mimeType: string;
+}, {}, {}>;
+/**
+ * An image provided to or from an LLM.
+ *
+ * @since 1.0.0
+ * @category Prompts
+ */
+export declare class ImageContent extends ImageContent_base {
+}
+declare const AudioContent_base: Schema.Class<AudioContent, {
+    type: Schema.tag<"audio">;
+    /**
+     * The audio data.
+     */
+    data: Schema.Schema<Uint8Array<ArrayBufferLike>, string, never>;
+    /**
+     * The MIME type of the audio. Different providers may support different
+     * audio types.
+     */
+    mimeType: typeof Schema.String;
+    /**
+     * Optional annotations for the client.
+     */
+    annotations: Schema.optional<typeof Annotations>;
+}, Schema.Struct.Encoded<{
+    type: Schema.tag<"audio">;
+    /**
+     * The audio data.
+     */
+    data: Schema.Schema<Uint8Array<ArrayBufferLike>, string, never>;
+    /**
+     * The MIME type of the audio. Different providers may support different
+     * audio types.
+     */
+    mimeType: typeof Schema.String;
+    /**
+     * Optional annotations for the client.
+     */
+    annotations: Schema.optional<typeof Annotations>;
+}>, never, {
+    readonly annotations?: Annotations | undefined;
+} & {
+    readonly type?: "audio" | undefined;
+} & {
+    readonly data: Uint8Array<ArrayBufferLike>;
+} & {
+    readonly mimeType: string;
+}, {}, {}>;
+/**
+ * Audio provided to or from an LLM.
+ *
+ * @since 1.0.0
+ * @category Prompts
+ */
+export declare class AudioContent extends AudioContent_base {
+}
+declare const EmbeddedResource_base: Schema.Class<EmbeddedResource, {
+    type: Schema.tag<"resource">;
+    resource: Schema.Union<[typeof TextResourceContents, typeof BlobResourceContents]>;
+    /**
+     * Optional annotations for the client.
+     */
+    annotations: Schema.optional<typeof Annotations>;
+}, Schema.Struct.Encoded<{
+    type: Schema.tag<"resource">;
+    resource: Schema.Union<[typeof TextResourceContents, typeof BlobResourceContents]>;
+    /**
+     * Optional annotations for the client.
+     */
+    annotations: Schema.optional<typeof Annotations>;
+}>, never, {
+    readonly annotations?: Annotations | undefined;
+} & {
+    readonly type?: "resource" | undefined;
+} & {
+    readonly resource: TextResourceContents | BlobResourceContents;
+}, {}, {}>;
+/**
+ * The contents of a resource, embedded into a prompt or tool call result.
+ *
+ * It is up to the client how best to render embedded resources for the benefit
+ * of the LLM and/or the user.
+ *
+ * @since 1.0.0
+ * @category Prompts
+ */
+export declare class EmbeddedResource extends EmbeddedResource_base {
+}
+declare const PromptMessage_base: Schema.Class<PromptMessage, {
+    role: Schema.Literal<["user", "assistant"]>;
+    content: Schema.Union<[typeof TextContent, typeof ImageContent, typeof AudioContent, typeof EmbeddedResource]>;
+}, Schema.Struct.Encoded<{
+    role: Schema.Literal<["user", "assistant"]>;
+    content: Schema.Union<[typeof TextContent, typeof ImageContent, typeof AudioContent, typeof EmbeddedResource]>;
+}>, never, {
+    readonly role: "user" | "assistant";
+} & {
+    readonly content: TextContent | ImageContent | AudioContent | EmbeddedResource;
+}, {}, {}>;
+/**
+ * Describes a message returned as part of a prompt.
+ *
+ * This is similar to `SamplingMessage`, but also supports the embedding of
+ * resources from the MCP server.
+ *
+ * @since 1.0.0
+ * @category Prompts
+ */
+export declare class PromptMessage extends PromptMessage_base {
+}
+declare const ListPromptsResult_base: Schema.Class<ListPromptsResult, {
+    prompts: Schema.Array$<typeof Prompt>;
+    nextCursor: Schema.optional<typeof Schema.String>;
+    _meta: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+}, Schema.Struct.Encoded<{
+    prompts: Schema.Array$<typeof Prompt>;
+    nextCursor: Schema.optional<typeof Schema.String>;
+    _meta: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+}>, never, {
+    readonly _meta?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+} & {
+    readonly nextCursor?: string | undefined;
+} & {
+    readonly prompts: readonly Prompt[];
+}, {}, {}>;
+/**
+ * The server's response to a prompts/list request from the client.
+ *
+ * @since 1.0.0
+ * @category Prompts
+ */
+export declare class ListPromptsResult extends ListPromptsResult_base {
+}
+declare const ListPrompts_base: Rpc.Rpc<"prompts/list", typeof PaginatedRequestMeta, typeof ListPromptsResult, typeof McpError, never>;
+/**
+ * Sent from the client to request a list of prompts and prompt templates the
+ * server has.
+ *
+ * @since 1.0.0
+ * @category Prompts
+ */
+export declare class ListPrompts extends ListPrompts_base {
+}
+declare const GetPromptResult_base: Schema.Class<GetPromptResult, {
+    messages: Schema.Array$<typeof PromptMessage>;
+    /**
+     * An optional description for the prompt.
+     */
+    description: Schema.optional<typeof Schema.String>;
+    _meta: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+}, Schema.Struct.Encoded<{
+    messages: Schema.Array$<typeof PromptMessage>;
+    /**
+     * An optional description for the prompt.
+     */
+    description: Schema.optional<typeof Schema.String>;
+    _meta: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+}>, never, {
+    readonly description?: string | undefined;
+} & {
+    readonly messages: readonly PromptMessage[];
+} & {
+    readonly _meta?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+}, {}, {}>;
+/**
+ * The server's response to a prompts/get request from the client.
+ *
+ * @since 1.0.0
+ * @category Prompts
+ */
+export declare class GetPromptResult extends GetPromptResult_base {
+}
+declare const GetPrompt_base: Rpc.Rpc<"prompts/get", Schema.Struct<{
+    /**
+     * The name of the prompt or prompt template.
+     */
+    name: typeof Schema.String;
+    /**
+     * Arguments to use for templating the prompt.
+     */
+    arguments: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+    _meta: Schema.optional<Schema.Struct<{
+        /**
+         * If specified, the caller is requesting out-of-band progress notifications
+         * for this request (as represented by notifications/progress). The value of
+         * this parameter is an opaque token that will be attached to any subsequent
+         * notifications. The receiver is not obligated to provide these
+         * notifications.
+         */
+        progressToken: Schema.optional<Schema.Union<[typeof Schema.String, typeof Schema.Number]>>;
+    }>>;
+}>, typeof GetPromptResult, typeof McpError, never>;
+/**
+ * Used by the client to get a prompt provided by the server.
+ *
+ * @since 1.0.0
+ * @category Prompts
+ */
+export declare class GetPrompt extends GetPrompt_base {
+}
+declare const PromptListChangedNotification_base: Rpc.Rpc<"notifications/prompts/list_changed", typeof NotificationMeta, typeof Schema.Void, typeof Schema.Never, never>;
+/**
+ * An optional notification from the server to the client, informing it that
+ * the list of prompts it offers has changed. This may be issued by servers
+ * without any previous subscription from the client.
+ *
+ * @since 1.0.0
+ * @category Prompts
+ */
+export declare class PromptListChangedNotification extends PromptListChangedNotification_base {
+}
+declare const ToolAnnotations_base: Schema.Class<ToolAnnotations, {
+    /**
+     * A human-readable title for the tool.
+     */
+    title: Schema.optional<typeof Schema.String>;
+    /**
+     * If true, the tool does not modify its environment.
+     *
+     * Default: `false`
+     */
+    readOnlyHint: Schema.optionalWith<typeof Schema.Boolean, {
+        default: () => false;
+    }>;
+    /**
+     * If true, the tool may perform destructive updates to its environment.
+     * If false, the tool performs only additive updates.
+     *
+     * (This property is meaningful only when `readOnlyHint == false`)
+     *
+     * Default: `true`
+     */
+    destructiveHint: Schema.optionalWith<typeof Schema.Boolean, {
+        default: () => true;
+    }>;
+    /**
+     * If true, calling the tool repeatedly with the same arguments
+     * will have no additional effect on the its environment.
+     *
+     * (This property is meaningful only when `readOnlyHint == false`)
+     *
+     * Default: `false`
+     */
+    idempotentHint: Schema.optionalWith<typeof Schema.Boolean, {
+        default: () => false;
+    }>;
+    /**
+     * If true, this tool may interact with an "open world" of external
+     * entities. If false, the tool's domain of interaction is closed.
+     * For example, the world of a web search tool is open, whereas that
+     * of a memory tool is not.
+     *
+     * Default: `true`
+     */
+    openWorldHint: Schema.optionalWith<typeof Schema.Boolean, {
+        default: () => true;
+    }>;
+}, Schema.Struct.Encoded<{
+    /**
+     * A human-readable title for the tool.
+     */
+    title: Schema.optional<typeof Schema.String>;
+    /**
+     * If true, the tool does not modify its environment.
+     *
+     * Default: `false`
+     */
+    readOnlyHint: Schema.optionalWith<typeof Schema.Boolean, {
+        default: () => false;
+    }>;
+    /**
+     * If true, the tool may perform destructive updates to its environment.
+     * If false, the tool performs only additive updates.
+     *
+     * (This property is meaningful only when `readOnlyHint == false`)
+     *
+     * Default: `true`
+     */
+    destructiveHint: Schema.optionalWith<typeof Schema.Boolean, {
+        default: () => true;
+    }>;
+    /**
+     * If true, calling the tool repeatedly with the same arguments
+     * will have no additional effect on the its environment.
+     *
+     * (This property is meaningful only when `readOnlyHint == false`)
+     *
+     * Default: `false`
+     */
+    idempotentHint: Schema.optionalWith<typeof Schema.Boolean, {
+        default: () => false;
+    }>;
+    /**
+     * If true, this tool may interact with an "open world" of external
+     * entities. If false, the tool's domain of interaction is closed.
+     * For example, the world of a web search tool is open, whereas that
+     * of a memory tool is not.
+     *
+     * Default: `true`
+     */
+    openWorldHint: Schema.optionalWith<typeof Schema.Boolean, {
+        default: () => true;
+    }>;
+}>, never, {
+    readonly title?: string | undefined;
+} & {
+    readonly readOnlyHint?: boolean | undefined;
+} & {
+    readonly destructiveHint?: boolean | undefined;
+} & {
+    readonly idempotentHint?: boolean | undefined;
+} & {
+    readonly openWorldHint?: boolean | undefined;
+}, {}, {}>;
+/**
+ * Additional properties describing a Tool to clients.
+ *
+ * NOTE: all properties in ToolAnnotations are **hints**. They are not
+ * guaranteed to provide a faithful description of tool behavior (including
+ * descriptive properties like `title`).
+ *
+ * Clients should never make tool use decisions based on ToolAnnotations
+ * received from untrusted servers.
+ *
+ * @since 1.0.0
+ * @category Tools
+ */
+export declare class ToolAnnotations extends ToolAnnotations_base {
+}
+declare const Tool_base: Schema.Class<Tool, {
+    /**
+     * The name of the tool.
+     */
+    name: typeof Schema.String;
+    /**
+     * A human-readable description of the tool.
+     *
+     * This can be used by clients to improve the LLM's understanding of available tools. It can be thought of like a "hint" to the model.
+     */
+    description: Schema.optional<typeof Schema.String>;
+    /**
+     * A JSON Schema object defining the expected parameters for the tool.
+     */
+    inputSchema: typeof Schema.Unknown;
+    /**
+     * Optional additional tool information.
+     */
+    annotations: Schema.optional<typeof ToolAnnotations>;
+}, Schema.Struct.Encoded<{
+    /**
+     * The name of the tool.
+     */
+    name: typeof Schema.String;
+    /**
+     * A human-readable description of the tool.
+     *
+     * This can be used by clients to improve the LLM's understanding of available tools. It can be thought of like a "hint" to the model.
+     */
+    description: Schema.optional<typeof Schema.String>;
+    /**
+     * A JSON Schema object defining the expected parameters for the tool.
+     */
+    inputSchema: typeof Schema.Unknown;
+    /**
+     * Optional additional tool information.
+     */
+    annotations: Schema.optional<typeof ToolAnnotations>;
+}>, never, {
+    readonly description?: string | undefined;
+} & {
+    readonly annotations?: ToolAnnotations | undefined;
+} & {
+    readonly name: string;
+} & {
+    readonly inputSchema: unknown;
+}, {}, {}>;
+/**
+ * Definition for a tool the client can call.
+ *
+ * @since 1.0.0
+ * @category Tools
+ */
+export declare class Tool extends Tool_base {
+}
+declare const ListToolsResult_base: Schema.Class<ListToolsResult, {
+    tools: Schema.Array$<typeof Tool>;
+    nextCursor: Schema.optional<typeof Schema.String>;
+    _meta: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+}, Schema.Struct.Encoded<{
+    tools: Schema.Array$<typeof Tool>;
+    nextCursor: Schema.optional<typeof Schema.String>;
+    _meta: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+}>, never, {
+    readonly tools: readonly Tool[];
+} & {
+    readonly _meta?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+} & {
+    readonly nextCursor?: string | undefined;
+}, {}, {}>;
+/**
+ * The server's response to a tools/list request from the client.
+ *
+ * @since 1.0.0
+ * @category Tools
+ */
+export declare class ListToolsResult extends ListToolsResult_base {
+}
+declare const ListTools_base: Rpc.Rpc<"tools/list", typeof PaginatedRequestMeta, typeof ListToolsResult, typeof McpError, never>;
+/**
+ * Sent from the client to request a list of tools the server has.
+ *
+ * @since 1.0.0
+ * @category Tools
+ */
+export declare class ListTools extends ListTools_base {
+}
+declare const CallToolResult_base: Schema.Class<CallToolResult, {
+    content: Schema.Array$<Schema.Union<[typeof TextContent, typeof ImageContent, typeof AudioContent, typeof EmbeddedResource]>>;
+    /**
+     * Whether the tool call ended in an error.
+     *
+     * If not set, this is assumed to be false (the call was successful).
+     */
+    isError: Schema.optional<typeof Schema.Boolean>;
+    _meta: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+}, Schema.Struct.Encoded<{
+    content: Schema.Array$<Schema.Union<[typeof TextContent, typeof ImageContent, typeof AudioContent, typeof EmbeddedResource]>>;
+    /**
+     * Whether the tool call ended in an error.
+     *
+     * If not set, this is assumed to be false (the call was successful).
+     */
+    isError: Schema.optional<typeof Schema.Boolean>;
+    _meta: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+}>, never, {
+    readonly _meta?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+} & {
+    readonly content: readonly (TextContent | ImageContent | AudioContent | EmbeddedResource)[];
+} & {
+    readonly isError?: boolean | undefined;
+}, {}, {}>;
+/**
+ * The server's response to a tool call.
+ *
+ * Any errors that originate from the tool SHOULD be reported inside the result
+ * object, with `isError` set to true, _not_ as an MCP protocol-level error
+ * response. Otherwise, the LLM would not be able to see that an error occurred
+ * and self-correct.
+ *
+ * However, any errors in _finding_ the tool, an error indicating that the
+ * server does not support tool calls, or any other exceptional conditions,
+ * should be reported as an MCP error response.
+ *
+ * @since 1.0.0
+ * @category Tools
+ */
+export declare class CallToolResult extends CallToolResult_base {
+}
+declare const CallTool_base: Rpc.Rpc<"tools/call", Schema.Struct<{
+    name: typeof Schema.String;
+    arguments: Schema.Record$<typeof Schema.String, typeof Schema.Unknown>;
+    _meta: Schema.optional<Schema.Struct<{
+        /**
+         * If specified, the caller is requesting out-of-band progress notifications
+         * for this request (as represented by notifications/progress). The value of
+         * this parameter is an opaque token that will be attached to any subsequent
+         * notifications. The receiver is not obligated to provide these
+         * notifications.
+         */
+        progressToken: Schema.optional<Schema.Union<[typeof Schema.String, typeof Schema.Number]>>;
+    }>>;
+}>, typeof CallToolResult, typeof McpError, never>;
+/**
+ * Used by the client to invoke a tool provided by the server.
+ *
+ * @since 1.0.0
+ * @category Tools
+ */
+export declare class CallTool extends CallTool_base {
+}
+declare const ToolListChangedNotification_base: Rpc.Rpc<"notifications/tools/list_changed", typeof NotificationMeta, typeof Schema.Void, typeof Schema.Never, never>;
+/**
+ * An optional notification from the server to the client, informing it that
+ * the list of tools it offers has changed. This may be issued by servers
+ * without any previous subscription from the client.
+ *
+ * @since 1.0.0
+ * @category Tools
+ */
+export declare class ToolListChangedNotification extends ToolListChangedNotification_base {
+}
+/**
+ * The severity of a log message.
+ *
+ * These map to syslog message severities, as specified in RFC-5424:
+ * https://datatracker.ietf.org/doc/html/rfc5424#section-6.2.1
+ *
+ * @since 1.0.0
+ * @category Logging
+ */
+export declare const LoggingLevel: Schema.Literal<[
+    "debug",
+    "info",
+    "notice",
+    "warning",
+    "error",
+    "critical",
+    "alert",
+    "emergency"
+]>;
+/**
+ * The severity of a log message.
+ *
+ * These map to syslog message severities, as specified in RFC-5424:
+ * https://datatracker.ietf.org/doc/html/rfc5424#section-6.2.1
+ *
+ * @since 1.0.0
+ * @category Logging
+ */
+export type LoggingLevel = typeof LoggingLevel.Type;
+declare const SetLevel_base: Rpc.Rpc<"logging/setLevel", Schema.Struct<{
+    /**
+     * The level of logging that the client wants to receive from the server.
+     * The server should send all logs at this level and higher (i.e., more
+     * severe) to the client as notifications/message.
+     */
+    level: Schema.Literal<["debug", "info", "notice", "warning", "error", "critical", "alert", "emergency"]>;
+    _meta: Schema.optional<Schema.Struct<{
+        /**
+         * If specified, the caller is requesting out-of-band progress notifications
+         * for this request (as represented by notifications/progress). The value of
+         * this parameter is an opaque token that will be attached to any subsequent
+         * notifications. The receiver is not obligated to provide these
+         * notifications.
+         */
+        progressToken: Schema.optional<Schema.Union<[typeof Schema.String, typeof Schema.Number]>>;
+    }>>;
+}>, typeof Schema.Void, typeof McpError, never>;
+/**
+ * A request from the client to the server, to enable or adjust logging.
+ *
+ * @since 1.0.0
+ * @category Logging
+ */
+export declare class SetLevel extends SetLevel_base {
+}
+declare const LoggingMessageNotification_base: Rpc.Rpc<"notifications/message", Schema.Struct<{
+    /**
+     * The severity of this log message.
+     */
+    level: Schema.Literal<["debug", "info", "notice", "warning", "error", "critical", "alert", "emergency"]>;
+    /**
+     * An optional name of the logger issuing this message.
+     */
+    logger: Schema.optional<typeof Schema.String>;
+    /**
+     * The data to be logged, such as a string message or an object. Any JSON
+     * serializable type is allowed here.
+     */
+    data: typeof Schema.Unknown;
+    _meta: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+}>, typeof Schema.Void, typeof Schema.Never, never>;
+/**
+ * @since 1.0.0
+ * @category Logging
+ */
+export declare class LoggingMessageNotification extends LoggingMessageNotification_base {
+}
+declare const SamplingMessage_base: Schema.Class<SamplingMessage, {
+    role: Schema.Literal<["user", "assistant"]>;
+    content: Schema.Union<[typeof TextContent, typeof ImageContent, typeof AudioContent]>;
+}, Schema.Struct.Encoded<{
+    role: Schema.Literal<["user", "assistant"]>;
+    content: Schema.Union<[typeof TextContent, typeof ImageContent, typeof AudioContent]>;
+}>, never, {
+    readonly role: "user" | "assistant";
+} & {
+    readonly content: TextContent | ImageContent | AudioContent;
+}, {}, {}>;
+/**
+ * Describes a message issued to or received from an LLM API.
+ *
+ * @since 1.0.0
+ * @category Sampling
+ */
+export declare class SamplingMessage extends SamplingMessage_base {
+}
+declare const ModelHint_base: Schema.Class<ModelHint, {
+    /**
+     * A hint for a model name.
+     *
+     * The client SHOULD treat this as a substring of a model name; for example:
+     *  - `claude-3-5-sonnet` should match `claude-3-5-sonnet-20241022`
+     *  - `sonnet` should match `claude-3-5-sonnet-20241022`, `claude-3-sonnet-20240229`, etc.
+     *  - `claude` should match any Claude model
+     *
+     * The client MAY also map the string to a different provider's model name or
+     * a different model family, as long as it fills a similar niche; for example:
+     *  - `gemini-1.5-flash` could match `claude-3-haiku-20240307`
+     */
+    name: Schema.optional<typeof Schema.String>;
+}, Schema.Struct.Encoded<{
+    /**
+     * A hint for a model name.
+     *
+     * The client SHOULD treat this as a substring of a model name; for example:
+     *  - `claude-3-5-sonnet` should match `claude-3-5-sonnet-20241022`
+     *  - `sonnet` should match `claude-3-5-sonnet-20241022`, `claude-3-sonnet-20240229`, etc.
+     *  - `claude` should match any Claude model
+     *
+     * The client MAY also map the string to a different provider's model name or
+     * a different model family, as long as it fills a similar niche; for example:
+     *  - `gemini-1.5-flash` could match `claude-3-haiku-20240307`
+     */
+    name: Schema.optional<typeof Schema.String>;
+}>, never, {
+    readonly name?: string | undefined;
+}, {}, {}>;
+/**
+ * Hints to use for model selection.
+ *
+ * Keys not declared here are currently left unspecified by the spec and are up
+ * to the client to interpret.
+ *
+ * @since 1.0.0
+ * @category Sampling
+ */
+export declare class ModelHint extends ModelHint_base {
+}
+declare const ModelPreferences_base: Schema.Class<ModelPreferences, {
+    /**
+     * Optional hints to use for model selection.
+     *
+     * If multiple hints are specified, the client MUST evaluate them in order
+     * (such that the first match is taken).
+     *
+     * The client SHOULD prioritize these hints over the numeric priorities, but
+     * MAY still use the priorities to select from ambiguous matches.
+     */
+    hints: Schema.optional<Schema.Array$<typeof ModelHint>>;
+    /**
+     * How much to prioritize cost when selecting a model. A value of 0 means cost
+     * is not important, while a value of 1 means cost is the most important
+     * factor.
+     */
+    costPriority: Schema.optional<Schema.filter<typeof Schema.Number>>;
+    /**
+     * How much to prioritize sampling speed (latency) when selecting a model. A
+     * value of 0 means speed is not important, while a value of 1 means speed is
+     * the most important factor.
+     */
+    speedPriority: Schema.optional<Schema.filter<typeof Schema.Number>>;
+    /**
+     * How much to prioritize intelligence and capabilities when selecting a
+     * model. A value of 0 means intelligence is not important, while a value of 1
+     * means intelligence is the most important factor.
+     */
+    intelligencePriority: Schema.optional<Schema.filter<typeof Schema.Number>>;
+}, Schema.Struct.Encoded<{
+    /**
+     * Optional hints to use for model selection.
+     *
+     * If multiple hints are specified, the client MUST evaluate them in order
+     * (such that the first match is taken).
+     *
+     * The client SHOULD prioritize these hints over the numeric priorities, but
+     * MAY still use the priorities to select from ambiguous matches.
+     */
+    hints: Schema.optional<Schema.Array$<typeof ModelHint>>;
+    /**
+     * How much to prioritize cost when selecting a model. A value of 0 means cost
+     * is not important, while a value of 1 means cost is the most important
+     * factor.
+     */
+    costPriority: Schema.optional<Schema.filter<typeof Schema.Number>>;
+    /**
+     * How much to prioritize sampling speed (latency) when selecting a model. A
+     * value of 0 means speed is not important, while a value of 1 means speed is
+     * the most important factor.
+     */
+    speedPriority: Schema.optional<Schema.filter<typeof Schema.Number>>;
+    /**
+     * How much to prioritize intelligence and capabilities when selecting a
+     * model. A value of 0 means intelligence is not important, while a value of 1
+     * means intelligence is the most important factor.
+     */
+    intelligencePriority: Schema.optional<Schema.filter<typeof Schema.Number>>;
+}>, never, {
+    readonly hints?: readonly ModelHint[] | undefined;
+} & {
+    readonly costPriority?: number | undefined;
+} & {
+    readonly speedPriority?: number | undefined;
+} & {
+    readonly intelligencePriority?: number | undefined;
+}, {}, {}>;
+/**
+ * The server's preferences for model selection, requested of the client during sampling.
+ *
+ * Because LLMs can vary along multiple dimensions, choosing the "best" model is
+ * rarely straightforward.  Different models excel in different areas—some are
+ * faster but less capable, others are more capable but more expensive, and so
+ * on. This interface allows servers to express their priorities across multiple
+ * dimensions to help clients make an appropriate selection for their use case.
+ *
+ * These preferences are always advisory. The client MAY ignore them. It is also
+ * up to the client to decide how to interpret these preferences and how to
+ * balance them against other considerations.
+ *
+ * @since 1.0.0
+ * @category Sampling
+ */
+export declare class ModelPreferences extends ModelPreferences_base {
+}
+declare const CreateMessageResult_base: Schema.Class<CreateMessageResult, {
+    /**
+     * The name of the model that generated the message.
+     */
+    model: typeof Schema.String;
+    /**
+     * The reason why sampling stopped, if known.
+     */
+    stopReason: Schema.optional<typeof Schema.String>;
+}, Schema.Struct.Encoded<{
+    /**
+     * The name of the model that generated the message.
+     */
+    model: typeof Schema.String;
+    /**
+     * The reason why sampling stopped, if known.
+     */
+    stopReason: Schema.optional<typeof Schema.String>;
+}>, never, {
+    readonly model: string;
+} & {
+    readonly stopReason?: string | undefined;
+}, {}, {}>;
+/**
+ * The client's response to a sampling/create_message request from the server.
+ * The client should inform the user before returning the sampled message, to
+ * allow them to inspect the response (human in the loop) and decide whether to
+ * allow the server to see it.
+ *
+ * @since 1.0.0
+ * @category Sampling
+ */
+export declare class CreateMessageResult extends CreateMessageResult_base {
+}
+declare const CreateMessage_base: Rpc.Rpc<"sampling/createMessage", Schema.Struct<{
+    messages: Schema.Array$<typeof SamplingMessage>;
+    /**
+     * The server's preferences for which model to select. The client MAY ignore
+     * these preferences.
+     */
+    modelPreferences: Schema.optional<typeof ModelPreferences>;
+    /**
+     * An optional system prompt the server wants to use for sampling. The
+     * client MAY modify or omit this prompt.
+     */
+    systemPrompt: Schema.optional<typeof Schema.String>;
+    /**
+     * A request to include context from one or more MCP servers (including the
+     * caller), to be attached to the prompt. The client MAY ignore this request.
+     */
+    includeContext: Schema.optional<Schema.Literal<["none", "thisServer", "allServers"]>>;
+    temperature: Schema.optional<typeof Schema.Number>;
+    /**
+     * The maximum number of tokens to sample, as requested by the server. The
+     * client MAY choose to sample fewer tokens than requested.
+     */
+    maxTokens: typeof Schema.Number;
+    stopSequences: Schema.optional<Schema.Array$<typeof Schema.String>>;
+    /**
+     * Optional metadata to pass through to the LLM provider. The format of
+     * this metadata is provider-specific.
+     */
+    metadata: typeof Schema.Unknown;
+}>, typeof CreateMessageResult, typeof McpError, never>;
+/**
+ * A request from the server to sample an LLM via the client. The client has
+ * full discretion over which model to select. The client should also inform the
+ * user before beginning sampling, to allow them to inspect the request (human
+ * in the loop) and decide whether to approve it.
+ *
+ * @since 1.0.0
+ * @category Sampling
+ */
+export declare class CreateMessage extends CreateMessage_base {
+}
+declare const ResourceReference_base: Schema.Class<ResourceReference, {
+    type: Schema.tag<"ref/resource">;
+    /**
+     * The URI or URI template of the resource.
+     */
+    uri: typeof Schema.String;
+}, Schema.Struct.Encoded<{
+    type: Schema.tag<"ref/resource">;
+    /**
+     * The URI or URI template of the resource.
+     */
+    uri: typeof Schema.String;
+}>, never, {
+    readonly type?: "ref/resource" | undefined;
+} & {
+    readonly uri: string;
+}, {}, {}>;
+/**
+ * A reference to a resource or resource template definition.
+ *
+ * @since 1.0.0
+ * @category Autocomplete
+ */
+export declare class ResourceReference extends ResourceReference_base {
+}
+declare const PromptReference_base: Schema.Class<PromptReference, {
+    type: Schema.tag<"ref/prompt">;
+    /**
+     * The name of the prompt or prompt template
+     */
+    name: typeof Schema.String;
+}, Schema.Struct.Encoded<{
+    type: Schema.tag<"ref/prompt">;
+    /**
+     * The name of the prompt or prompt template
+     */
+    name: typeof Schema.String;
+}>, never, {
+    readonly name: string;
+} & {
+    readonly type?: "ref/prompt" | undefined;
+}, {}, {}>;
+/**
+ * Identifies a prompt.
+ *
+ * @since 1.0.0
+ * @category Autocomplete
+ */
+export declare class PromptReference extends PromptReference_base {
+}
+declare const CompleteResult_base: Schema.Class<CompleteResult, {
+    completion: Schema.Struct<{
+        /**
+         * An array of completion values. Must not exceed 100 items.
+         */
+        values: Schema.Array$<typeof Schema.String>;
+        /**
+         * The total number of completion options available. This can exceed the
+         * number of values actually sent in the response.
+         */
+        total: Schema.optional<typeof Schema.Number>;
+        /**
+         * Indicates whether there are additional completion options beyond those
+         * provided in the current response, even if the exact total is unknown.
+         */
+        hasMore: Schema.optional<typeof Schema.Boolean>;
+    }>;
+}, Schema.Struct.Encoded<{
+    completion: Schema.Struct<{
+        /**
+         * An array of completion values. Must not exceed 100 items.
+         */
+        values: Schema.Array$<typeof Schema.String>;
+        /**
+         * The total number of completion options available. This can exceed the
+         * number of values actually sent in the response.
+         */
+        total: Schema.optional<typeof Schema.Number>;
+        /**
+         * Indicates whether there are additional completion options beyond those
+         * provided in the current response, even if the exact total is unknown.
+         */
+        hasMore: Schema.optional<typeof Schema.Boolean>;
+    }>;
+}>, never, {
+    readonly completion: {
+        readonly values: readonly string[];
+        readonly total?: number | undefined;
+        readonly hasMore?: boolean | undefined;
+    };
+}, {}, {}>;
+/**
+ * The server's response to a completion/complete request
+ *
+ * @since 1.0.0
+ * @category Autocomplete
+ */
+export declare class CompleteResult extends CompleteResult_base {
+    /**
+     * @since 1.0.0
+     */
+    static readonly empty: CompleteResult;
+}
+declare const Complete_base: Rpc.Rpc<"completion/complete", Schema.Struct<{
+    ref: Schema.Union<[typeof PromptReference, typeof ResourceReference]>;
+    /**
+     * The argument's information
+     */
+    argument: Schema.Struct<{
+        /**
+         * The name of the argument
+         */
+        name: typeof Schema.String;
+        /**
+         * The value of the argument to use for completion matching.
+         */
+        value: typeof Schema.String;
+    }>;
+}>, typeof CompleteResult, typeof McpError, never>;
+/**
+ * A request from the client to the server, to ask for completion options.
+ *
+ * @since 1.0.0
+ * @category Autocomplete
+ */
+export declare class Complete extends Complete_base {
+}
+declare const Root_base: Schema.Class<Root, {
+    /**
+     * The URI identifying the root. This *must* start with file:// for now.
+     * This restriction may be relaxed in future versions of the protocol to allow
+     * other URI schemes.
+     */
+    uri: typeof Schema.String;
+    /**
+     * An optional name for the root. This can be used to provide a human-readable
+     * identifier for the root, which may be useful for display purposes or for
+     * referencing the root in other parts of the application.
+     */
+    name: Schema.optional<typeof Schema.String>;
+}, Schema.Struct.Encoded<{
+    /**
+     * The URI identifying the root. This *must* start with file:// for now.
+     * This restriction may be relaxed in future versions of the protocol to allow
+     * other URI schemes.
+     */
+    uri: typeof Schema.String;
+    /**
+     * An optional name for the root. This can be used to provide a human-readable
+     * identifier for the root, which may be useful for display purposes or for
+     * referencing the root in other parts of the application.
+     */
+    name: Schema.optional<typeof Schema.String>;
+}>, never, {
+    readonly name?: string | undefined;
+} & {
+    readonly uri: string;
+}, {}, {}>;
+/**
+ * Represents a root directory or file that the server can operate on.
+ *
+ * @since 1.0.0
+ * @category Roots
+ */
+export declare class Root extends Root_base {
+}
+declare const ListRootsResult_base: Schema.Class<ListRootsResult, {
+    roots: Schema.Array$<typeof Root>;
+}, Schema.Struct.Encoded<{
+    roots: Schema.Array$<typeof Root>;
+}>, never, {
+    readonly roots: readonly Root[];
+}, {}, {}>;
+/**
+ * The client's response to a roots/list request from the server. This result
+ * contains an array of Root objects, each representing a root directory or file
+ * that the server can operate on.
+ *
+ * @since 1.0.0
+ * @category Roots
+ */
+export declare class ListRootsResult extends ListRootsResult_base {
+}
+declare const ListRoots_base: Rpc.Rpc<"roots/list", typeof RequestMeta, typeof ListRootsResult, typeof McpError, never>;
+/**
+ * Sent from the server to request a list of root URIs from the client. Roots
+ * allow servers to ask for specific directories or files to operate on. A
+ * common example for roots is providing a set of repositories or directories a
+ * server should operate
+ * on.
+ *
+ * This request is typically used when the server needs to understand the file
+ * system structure or access specific locations that the client has permission
+ * to read from.
+ *
+ * @since 1.0.0
+ * @category Roots
+ */
+export declare class ListRoots extends ListRoots_base {
+}
+declare const RootsListChangedNotification_base: Rpc.Rpc<"notifications/roots/list_changed", typeof NotificationMeta, typeof Schema.Void, typeof Schema.Never, never>;
+/**
+ * A notification from the client to the server, informing it that the list of
+ * roots has changed. This notification should be sent whenever the client adds,
+ * removes, or modifies any root. The server should then request an updated list
+ * of roots using the ListRootsRequest.
+ *
+ * @since 1.0.0
+ * @category Roots
+ */
+export declare class RootsListChangedNotification extends RootsListChangedNotification_base {
+}
+/**
+ * @since 1.0.0
+ * @category Protocol
+ */
+export 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;
+/**
+ * @since 1.0.0
+ * @category Protocol
+ */
+export 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;
+/**
+ * @since 1.0.0
+ * @category Protocol
+ */
+export 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;
+/**
+ * @since 1.0.0
+ * @category Protocol
+ */
+export 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 id: string | number;
+    readonly error: _Error["Encoded"];
+} : never : never;
+declare const ClientRequestRpcs_base: RpcGroup.RpcGroup<typeof Ping | typeof Initialize | typeof ListResources | typeof ListResourceTemplates | typeof ReadResource | typeof Subscribe | typeof Unsubscribe | typeof ListPrompts | typeof GetPrompt | typeof ListTools | typeof CallTool | typeof SetLevel | typeof Complete>;
+/**
+ * @since 1.0.0
+ * @category Protocol
+ */
+export declare class ClientRequestRpcs extends ClientRequestRpcs_base {
+}
+/**
+ * @since 1.0.0
+ * @category Protocol
+ */
+export type ClientRequestEncoded = RequestEncoded<typeof ClientRequestRpcs>;
+declare const ClientNotificationRpcs_base: RpcGroup.RpcGroup<typeof InitializedNotification | typeof CancelledNotification | typeof ProgressNotification | typeof RootsListChangedNotification>;
+/**
+ * @since 1.0.0
+ * @category Protocol
+ */
+export declare class ClientNotificationRpcs extends ClientNotificationRpcs_base {
+}
+/**
+ * @since 1.0.0
+ * @category Protocol
+ */
+export type ClientNotificationEncoded = NotificationEncoded<typeof ClientNotificationRpcs>;
+declare const ClientRpcs_base: RpcGroup.RpcGroup<typeof Ping | typeof Initialize | typeof InitializedNotification | typeof CancelledNotification | typeof ProgressNotification | typeof ListResources | typeof ListResourceTemplates | typeof ReadResource | typeof Subscribe | typeof Unsubscribe | typeof ListPrompts | typeof GetPrompt | typeof ListTools | typeof CallTool | typeof SetLevel | typeof Complete | typeof RootsListChangedNotification>;
+/**
+ * @since 1.0.0
+ * @category Protocol
+ */
+export declare class ClientRpcs extends ClientRpcs_base {
+}
+/**
+ * @since 1.0.0
+ * @category Protocol
+ */
+export type ClientSuccessEncoded = SuccessEncoded<typeof ServerRequestRpcs>;
+/**
+ * @since 1.0.0
+ * @category Protocol
+ */
+export type ClientFailureEncoded = FailureEncoded<typeof ServerRequestRpcs>;
+declare const ServerRequestRpcs_base: RpcGroup.RpcGroup<typeof Ping | typeof CreateMessage | typeof ListRoots>;
+/**
+ * @since 1.0.0
+ * @category Protocol
+ */
+export declare class ServerRequestRpcs extends ServerRequestRpcs_base {
+}
+/**
+ * @since 1.0.0
+ * @category Protocol
+ */
+export type ServerRequestEncoded = RequestEncoded<typeof ServerRequestRpcs>;
+declare const ServerNotificationRpcs_base: RpcGroup.RpcGroup<typeof CancelledNotification | typeof ProgressNotification | typeof ResourceListChangedNotification | typeof ResourceUpdatedNotification | typeof PromptListChangedNotification | typeof ToolListChangedNotification | typeof LoggingMessageNotification>;
+/**
+ * @since 1.0.0
+ * @category Protocol
+ */
+export declare class ServerNotificationRpcs extends ServerNotificationRpcs_base {
+}
+/**
+ * @since 1.0.0
+ * @category Protocol
+ */
+export type ServerNotificationEncoded = NotificationEncoded<typeof ServerNotificationRpcs>;
+/**
+ * @since 1.0.0
+ * @category Protocol
+ */
+export type ServerSuccessEncoded = SuccessEncoded<typeof ClientRequestRpcs>;
+/**
+ * @since 1.0.0
+ * @category Protocol
+ */
+export type ServerFailureEncoded = FailureEncoded<typeof ClientRequestRpcs>;
+/**
+ * @since 1.0.0
+ * @category Protocol
+ */
+export type ServerResultEncoded = ServerSuccessEncoded | ServerFailureEncoded;
+/**
+ * @since 1.0.0
+ * @category Protocol
+ */
+export type FromClientEncoded = ClientRequestEncoded | ClientNotificationEncoded;
+/**
+ * @since 1.0.0
+ * @category Protocol
+ */
+export type FromServerEncoded = ServerResultEncoded | ServerNotificationEncoded;
+/**
+ * @since 1.0.0
+ * @category Parameters
+ */
+export declare const ParamAnnotation: unique symbol;
+/**
+ * @since 1.0.0
+ * @category Parameters
+ */
+export interface Param<Id extends string, S extends Schema.Schema.Any> extends Schema.Schema<S["Type"], S["Encoded"], S["Context"]> {
+    readonly [ParamAnnotation]: Id;
+}
+/**
+ * Helper to create a param for a resource URI template.
+ *
+ * @since 1.0.0
+ * @category Parameters
+ */
+export declare const param: <const Id extends string, S extends Schema.Schema.Any>(id: Id, schema: S) => Param<Id, S>;
+export {};
+//# sourceMappingURL=McpSchema.d.ts.map