McpSchema

declare class Complete extends any {
  constructor();
}

declare class CompleteResult extends ReadonlySide<
  {
    readonly completion: Struct<{
      readonly hasMore: optional<Boolean>;
      readonly total: optional<Number>;
      readonly values: $Array<String>;
    }>;
  },
  "Type"
> {
  constructor(
    ...args: [
      props: ReadonlyMakeIn<{
        readonly completion: Struct<{
          readonly hasMore: optional<Boolean>;
          readonly total: optional<Number>;
          readonly values: $Array<String>;
        }>;
      }>,
      options?: MakeOptions,
    ]
  );
  static readonly empty: CompleteResult;
}

declare class PromptReference extends any {
  constructor();
}

declare class ResourceReference extends any {
  constructor();
}

declare class CancelledNotification extends any {
  constructor();
}

declare class Annotations extends any {
  constructor();
}

declare class ClientCapabilities extends {
  readonly elicitation?: ReadonlySide<{}, "Type">;
  readonly experimental?: {
    [key: string]: unknown;
    [key: number]: unknown;
    [key: symbol]: unknown;
  };
  readonly roots?: {
    readonly listChanged?: boolean;
  };
  readonly sampling?: ReadonlySide<{}, "Type">;
} {
  constructor(...args: [props?: {
    readonly elicitation?: ReadonlyMakeIn<{}>;
    readonly experimental?: {
      [key: string]: unknown;
      [key: number]: unknown;
      [key: symbol]: unknown;
    };
    readonly roots?: {
      readonly listChanged?: boolean;
    };
    readonly sampling?: ReadonlyMakeIn<{}>;
  }, options?: MakeOptions]);
}

declare const Cursor: typeof Schema.String;

type Cursor = typeof Cursor.Type;

declare class Implementation extends any {
  constructor();
}

declare class NotificationMeta extends any {
  constructor();
}

declare class PaginatedRequestMeta extends any {
  constructor();
}

declare class PaginatedResultMeta extends any {
  constructor();
}

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

type ProgressToken = typeof ProgressToken.Type;

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

type RequestId = typeof RequestId.Type;

declare class RequestMeta extends any {
  constructor();
}

declare class ResultMeta extends any {
  constructor();
}

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

type Role = typeof Role.Type;

declare class ServerCapabilities extends any {
  constructor();
}

declare class Elicit extends any {
  constructor();
}

declare class ElicitAcceptResult extends {
  [key: number]: any;
  [key: symbol]: any;
  [key: string]: any;
} {
  [key: number]: any;
  [key: symbol]: any;
  [key: string]: any;
  constructor(...args: [props?: {
    [key: number]: any;
    [key: symbol]: any;
    [key: string]: any;
  }, options?: MakeOptions]);
}

declare class ElicitationDeclined extends any {
  constructor();
}

declare class ElicitDeclineResult extends {
  [key: number]: any;
  [key: symbol]: any;
  [key: string]: any;
} {
  [key: number]: any;
  [key: symbol]: any;
  [key: string]: any;
  constructor(...args: [props?: {
    [key: number]: any;
    [key: symbol]: any;
    [key: string]: any;
  }, options?: MakeOptions]);
}

declare const ElicitResult: Union<readonly Array<Constraint>>

declare const INTERNAL_ERROR_CODE: -32603;

declare class InternalError extends any {
  constructor();
  static readonly notImplemented: InternalError;
}

declare const INVALID_PARAMS_ERROR_CODE: -32602;

declare const INVALID_REQUEST_ERROR_CODE: -32600;

declare class InvalidParams extends any {
  constructor();
}

declare class InvalidRequest extends any {
  constructor();
}

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

declare const METHOD_NOT_FOUND_ERROR_CODE: -32601;

declare class MethodNotFound extends any {
  constructor();
}

declare const PARSE_ERROR_CODE: -32700;

declare class ParseError extends any {
  constructor();
}

declare class Initialize extends any {
  constructor();
}

declare class InitializedNotification extends any {
  constructor();
}

declare class InitializeResult extends {
  [key: number]: any;
  [key: symbol]: any;
  [key: string]: any;
} {
  [key: number]: any;
  [key: symbol]: any;
  [key: string]: any;
  constructor(...args: [props?: {
    [key: number]: any;
    [key: symbol]: any;
    [key: string]: any;
  }, options?: MakeOptions]);
}

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

type LoggingLevel = typeof LoggingLevel.Type;

declare class LoggingMessageNotification extends any {
  constructor();
}

declare class SetLevel extends any {
  constructor();
}

declare class McpServerClient extends any {
  constructor();
}

declare class McpServerClientMiddleware extends any {
  constructor();
}

declare function param<Id extends string, S extends Any>(id: Id, schema: S): Param<Id, S>;

interface Param<Id extends string, S extends Schema.Schema.Any> extends Schema<
  S["Type"],
  S["Encoded"],
  S["Context"]
> {
  readonly [ParamAnnotation]: Id;
}

declare const ParamAnnotation: unique symbol;

declare class Ping extends any {
  constructor();
}

declare class ProgressNotification extends any {
  constructor();
}

declare class AudioContent extends any {
  constructor();
}

declare class ContentBlock extends any {
  constructor();
}

declare class EmbeddedResource extends any {
  constructor();
}

declare class GetPrompt extends any {
  constructor();
}

declare class GetPromptResult extends {
  [key: number]: any;
  [key: symbol]: any;
  [key: string]: any;
} {
  [key: number]: any;
  [key: symbol]: any;
  [key: string]: any;
  constructor(...args: [props?: {
    [key: number]: any;
    [key: symbol]: any;
    [key: string]: any;
  }, options?: MakeOptions]);
}

declare class ImageContent extends any {
  constructor();
}

declare class ListPrompts extends any {
  constructor();
}

declare class ListPromptsResult extends {
  [key: number]: any;
  [key: symbol]: any;
  [key: string]: any;
} {
  [key: number]: any;
  [key: symbol]: any;
  [key: string]: any;
  constructor(...args: [props?: {
    [key: number]: any;
    [key: symbol]: any;
    [key: string]: any;
  }, options?: MakeOptions]);
}

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

declare class PromptArgument extends any {
  constructor();
}

declare class PromptListChangedNotification extends any {
  constructor();
}

declare class PromptMessage extends any {
  constructor();
}

declare class ResourceLink extends any {
  constructor();
}

declare class TextContent extends any {
  constructor();
}

type ClientFailureEncoded = FailureEncoded<typeof ServerRequestRpcs>;

type ClientNotificationEncoded = NotificationEncoded<typeof ClientNotificationRpcs>;

declare class ClientNotificationRpcs extends any {
  constructor();
}

type ClientRequestEncoded = RequestEncoded<typeof ClientRequestRpcs>;

declare class ClientRequestRpcs extends any {
  constructor();
}

declare class ClientRpcs extends any {
  constructor();
}

type ClientSuccessEncoded = SuccessEncoded<typeof ServerRequestRpcs>;

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;

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;

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;

type ServerFailureEncoded = FailureEncoded<typeof ClientRequestRpcs>;

type ServerNotificationEncoded = NotificationEncoded<typeof ServerNotificationRpcs>;

declare class ServerNotificationRpcs extends any {
  constructor();
}

type ServerRequestEncoded = RequestEncoded<typeof ServerRequestRpcs>;

declare class ServerRequestRpcs extends any {
  constructor();
}

type ServerResultEncoded = ServerSuccessEncoded | ServerFailureEncoded;

type ServerSuccessEncoded = SuccessEncoded<typeof ClientRequestRpcs>;

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 BlobResourceContents extends any {
  constructor();
}

declare class ListResources extends any {
  constructor();
}

declare class ListResourcesResult extends {
  [key: number]: any;
  [key: symbol]: any;
  [key: string]: any;
} {
  [key: number]: any;
  [key: symbol]: any;
  [key: string]: any;
  constructor(...args: [props?: {
    [key: number]: any;
    [key: symbol]: any;
    [key: string]: any;
  }, options?: MakeOptions]);
}

declare class ListResourceTemplates extends any {
  constructor();
}

declare class ListResourceTemplatesResult extends {
  [key: number]: any;
  [key: symbol]: any;
  [key: string]: any;
} {
  [key: number]: any;
  [key: symbol]: any;
  [key: string]: any;
  constructor(...args: [props?: {
    [key: number]: any;
    [key: symbol]: any;
    [key: string]: any;
  }, options?: MakeOptions]);
}

declare class ReadResource extends any {
  constructor();
}

declare class ReadResourceResult extends any {
  constructor();
}

declare class Resource extends {
  readonly annotations?: unknown;
  readonly description?: string;
  readonly mimeType?: string;
  readonly name: string;
  readonly size?: number;
  readonly title?: string;
  readonly uri: string;
} {
  constructor(...args: [props: {
    readonly annotations?: unknown;
    readonly description?: string;
    readonly mimeType?: string;
    readonly name: string;
    readonly size?: number;
    readonly title?: string;
    readonly uri: string;
  }, options?: MakeOptions]);
}

declare class ResourceContents extends any {
  constructor();
}

declare class ResourceListChangedNotification extends any {
  constructor();
}

declare class ResourceTemplate extends {
  readonly annotations?: unknown;
  readonly description?: string;
  readonly mimeType?: string;
  readonly name: string;
  readonly title?: string;
  readonly uriTemplate: string;
} {
  constructor(...args: [props: {
    readonly annotations?: unknown;
    readonly description?: string;
    readonly mimeType?: string;
    readonly name: string;
    readonly title?: string;
    readonly uriTemplate: string;
  }, options?: MakeOptions]);
}

declare class ResourceUpdatedNotification extends any {
  constructor();
}

declare class Subscribe extends any {
  constructor();
}

declare class TextResourceContents extends any {
  constructor();
}

declare class Unsubscribe extends any {
  constructor();
}

declare class ListRoots extends any {
  constructor();
}

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

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

declare class RootsListChangedNotification extends any {
  constructor();
}

declare class CreateMessage extends any {
  constructor();
}

declare class CreateMessageResult extends {
  readonly model: string;
  readonly stopReason?: string;
} {
  constructor(...args: [props: {
    readonly model: string;
    readonly stopReason?: string;
  }, options?: MakeOptions]);
}

declare class ModelHint extends any {
  constructor();
}

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

declare class SamplingMessage extends any {
  constructor();
}

declare class CallTool extends any {
  constructor();
}

declare class CallToolResult extends {
  [key: number]: any;
  [key: symbol]: any;
  [key: string]: any;
} {
  [key: number]: any;
  [key: symbol]: any;
  [key: string]: any;
  constructor(...args: [props?: {
    [key: number]: any;
    [key: symbol]: any;
    [key: string]: any;
  }, options?: MakeOptions]);
}

declare class ListTools extends any {
  constructor();
}

declare class ListToolsResult extends {
  [key: number]: any;
  [key: symbol]: any;
  [key: string]: any;
} {
  [key: number]: any;
  [key: symbol]: any;
  [key: string]: any;
  constructor(...args: [props?: {
    [key: number]: any;
    [key: symbol]: any;
    [key: string]: any;
  }, options?: MakeOptions]);
}

declare class Tool extends {
  readonly annotations?: ToolAnnotations;
  readonly description?: string;
  readonly inputSchema: unknown;
  readonly name: string;
  readonly title?: string;
} {
  constructor(...args: [props: {
    readonly annotations?: ToolAnnotations;
    readonly description?: string;
    readonly inputSchema: unknown;
    readonly name: string;
    readonly title?: string;
  }, options?: MakeOptions]);
}

declare class ToolAnnotations extends {
  [key: string]: any;
} {
  [key: string]: any;
  constructor(...args: [props?: {
    [key: string]: any;
  }, options?: MakeOptions]);
}

declare class ToolListChangedNotification extends any {
  constructor();
}