@effect/ai-anthropic 0.0.1

package/dist/dts/Generated.d.ts

@@ -0,0 +1,3937 @@
+/**
+ * @since 1.0.0
+ */
+import type * as HttpClient from "@effect/platform/HttpClient";
+import * as HttpClientError from "@effect/platform/HttpClientError";
+import * as Effect from "effect/Effect";
+import type { ParseError } from "effect/ParseResult";
+import * as S from "effect/Schema";
+declare const MessagesPostParams_base: S.Struct<{
+    "anthropic-version": S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+}>;
+export declare class MessagesPostParams extends MessagesPostParams_base {
+}
+declare const ModelEnum_base: S.Literal<["claude-3-5-haiku-latest", "claude-3-5-haiku-20241022", "claude-3-5-sonnet-latest", "claude-3-5-sonnet-20241022", "claude-3-5-sonnet-20240620", "claude-3-opus-latest", "claude-3-opus-20240229", "claude-3-sonnet-20240229", "claude-3-haiku-20240307", "claude-2.1", "claude-2.0"]>;
+export declare class ModelEnum extends ModelEnum_base {
+}
+declare const Model_base: S.Union<[typeof S.String, typeof ModelEnum]>;
+export declare class Model extends Model_base {
+}
+declare const InputMessageRole_base: S.Literal<["user", "assistant"]>;
+export declare class InputMessageRole extends InputMessageRole_base {
+}
+declare const CacheControlEphemeralType_base: S.Literal<["ephemeral"]>;
+export declare class CacheControlEphemeralType extends CacheControlEphemeralType_base {
+}
+declare const CacheControlEphemeral_base: S.Struct<{
+    type: typeof CacheControlEphemeralType;
+}>;
+export declare class CacheControlEphemeral extends CacheControlEphemeral_base {
+}
+declare const RequestCharLocationCitationType_base: S.Literal<["char_location"]>;
+export declare class RequestCharLocationCitationType extends RequestCharLocationCitationType_base {
+}
+declare const RequestCharLocationCitation_base: S.Struct<{
+    type: typeof RequestCharLocationCitationType;
+    cited_text: typeof S.String;
+    document_index: S.filter<S.Schema<number, number, never>>;
+    document_title: S.Union<[S.filter<S.Schema<string, string, never>>, typeof S.Null]>;
+    start_char_index: S.filter<S.Schema<number, number, never>>;
+    end_char_index: typeof S.Int;
+}>;
+export declare class RequestCharLocationCitation extends RequestCharLocationCitation_base {
+}
+declare const RequestPageLocationCitationType_base: S.Literal<["page_location"]>;
+export declare class RequestPageLocationCitationType extends RequestPageLocationCitationType_base {
+}
+declare const RequestPageLocationCitation_base: S.Struct<{
+    type: typeof RequestPageLocationCitationType;
+    cited_text: typeof S.String;
+    document_index: S.filter<S.Schema<number, number, never>>;
+    document_title: S.Union<[S.filter<S.Schema<string, string, never>>, typeof S.Null]>;
+    start_page_number: S.filter<S.Schema<number, number, never>>;
+    end_page_number: typeof S.Int;
+}>;
+export declare class RequestPageLocationCitation extends RequestPageLocationCitation_base {
+}
+declare const RequestContentBlockLocationCitationType_base: S.Literal<["content_block_location"]>;
+export declare class RequestContentBlockLocationCitationType extends RequestContentBlockLocationCitationType_base {
+}
+declare const RequestContentBlockLocationCitation_base: S.Struct<{
+    type: typeof RequestContentBlockLocationCitationType;
+    cited_text: typeof S.String;
+    document_index: S.filter<S.Schema<number, number, never>>;
+    document_title: S.Union<[S.filter<S.Schema<string, string, never>>, typeof S.Null]>;
+    start_block_index: S.filter<S.Schema<number, number, never>>;
+    end_block_index: typeof S.Int;
+}>;
+export declare class RequestContentBlockLocationCitation extends RequestContentBlockLocationCitation_base {
+}
+declare const RequestTextBlockType_base: S.Literal<["text"]>;
+export declare class RequestTextBlockType extends RequestTextBlockType_base {
+}
+declare const RequestTextBlock_base: S.Struct<{
+    cache_control: S.optionalWith<S.Union<[typeof CacheControlEphemeral, typeof S.Null]>, {
+        nullable: true;
+    }>;
+    citations: S.optionalWith<S.Union<[S.Array$<S.Union<[typeof RequestCharLocationCitation, typeof RequestPageLocationCitation, typeof RequestContentBlockLocationCitation]>>, typeof S.Null]>, {
+        nullable: true;
+    }>;
+    text: S.filter<S.Schema<string, string, never>>;
+    type: typeof RequestTextBlockType;
+}>;
+export declare class RequestTextBlock extends RequestTextBlock_base {
+}
+declare const RequestImageBlockType_base: S.Literal<["image"]>;
+export declare class RequestImageBlockType extends RequestImageBlockType_base {
+}
+declare const Base64ImageSourceType_base: S.Literal<["base64"]>;
+export declare class Base64ImageSourceType extends Base64ImageSourceType_base {
+}
+declare const Base64ImageSourceMediaType_base: S.Literal<["image/jpeg", "image/png", "image/gif", "image/webp"]>;
+export declare class Base64ImageSourceMediaType extends Base64ImageSourceMediaType_base {
+}
+declare const Base64ImageSource_base: S.Struct<{
+    type: typeof Base64ImageSourceType;
+    media_type: typeof Base64ImageSourceMediaType;
+    data: typeof S.String;
+}>;
+export declare class Base64ImageSource extends Base64ImageSource_base {
+}
+declare const RequestImageBlock_base: S.Struct<{
+    cache_control: S.optionalWith<S.Union<[typeof CacheControlEphemeral, typeof S.Null]>, {
+        nullable: true;
+    }>;
+    type: typeof RequestImageBlockType;
+    source: typeof Base64ImageSource;
+}>;
+export declare class RequestImageBlock extends RequestImageBlock_base {
+}
+declare const RequestToolUseBlockType_base: S.Literal<["tool_use"]>;
+export declare class RequestToolUseBlockType extends RequestToolUseBlockType_base {
+}
+declare const RequestToolUseBlock_base: S.Struct<{
+    cache_control: S.optionalWith<S.Union<[typeof CacheControlEphemeral, typeof S.Null]>, {
+        nullable: true;
+    }>;
+    type: typeof RequestToolUseBlockType;
+    id: S.filter<S.Schema<string, string, never>>;
+    name: S.filter<S.Schema<string, string, never>>;
+    input: S.Record$<typeof S.String, typeof S.Unknown>;
+}>;
+export declare class RequestToolUseBlock extends RequestToolUseBlock_base {
+}
+declare const RequestToolResultBlockType_base: S.Literal<["tool_result"]>;
+export declare class RequestToolResultBlockType extends RequestToolResultBlockType_base {
+}
+declare const RequestToolResultBlock_base: S.Struct<{
+    cache_control: S.optionalWith<S.Union<[typeof CacheControlEphemeral, typeof S.Null]>, {
+        nullable: true;
+    }>;
+    type: typeof RequestToolResultBlockType;
+    tool_use_id: S.filter<S.Schema<string, string, never>>;
+    is_error: S.optionalWith<typeof S.Boolean, {
+        nullable: true;
+    }>;
+    content: S.optionalWith<S.Union<[typeof S.String, S.Array$<S.Union<[typeof RequestTextBlock, typeof RequestImageBlock]>>]>, {
+        nullable: true;
+    }>;
+}>;
+export declare class RequestToolResultBlock extends RequestToolResultBlock_base {
+}
+declare const RequestDocumentBlockType_base: S.Literal<["document"]>;
+export declare class RequestDocumentBlockType extends RequestDocumentBlockType_base {
+}
+declare const Base64PDFSourceType_base: S.Literal<["base64"]>;
+export declare class Base64PDFSourceType extends Base64PDFSourceType_base {
+}
+declare const Base64PDFSourceMediaType_base: S.Literal<["application/pdf"]>;
+export declare class Base64PDFSourceMediaType extends Base64PDFSourceMediaType_base {
+}
+declare const Base64PDFSource_base: S.Struct<{
+    type: typeof Base64PDFSourceType;
+    media_type: typeof Base64PDFSourceMediaType;
+    data: typeof S.String;
+}>;
+export declare class Base64PDFSource extends Base64PDFSource_base {
+}
+declare const PlainTextSourceType_base: S.Literal<["text"]>;
+export declare class PlainTextSourceType extends PlainTextSourceType_base {
+}
+declare const PlainTextSourceMediaType_base: S.Literal<["text/plain"]>;
+export declare class PlainTextSourceMediaType extends PlainTextSourceMediaType_base {
+}
+declare const PlainTextSource_base: S.Struct<{
+    type: typeof PlainTextSourceType;
+    media_type: typeof PlainTextSourceMediaType;
+    data: typeof S.String;
+}>;
+export declare class PlainTextSource extends PlainTextSource_base {
+}
+declare const ContentBlockSourceType_base: S.Literal<["content"]>;
+export declare class ContentBlockSourceType extends ContentBlockSourceType_base {
+}
+declare const ContentBlockSource_base: S.Struct<{
+    type: typeof ContentBlockSourceType;
+    content: S.Union<[typeof S.String, S.Array$<S.Union<[typeof RequestTextBlock, typeof RequestImageBlock]>>]>;
+}>;
+export declare class ContentBlockSource extends ContentBlockSource_base {
+}
+declare const RequestCitationsConfig_base: S.Struct<{
+    enabled: S.optionalWith<typeof S.Boolean, {
+        nullable: true;
+    }>;
+}>;
+export declare class RequestCitationsConfig extends RequestCitationsConfig_base {
+}
+declare const RequestDocumentBlock_base: S.Struct<{
+    cache_control: S.optionalWith<S.Union<[typeof CacheControlEphemeral, typeof S.Null]>, {
+        nullable: true;
+    }>;
+    type: typeof RequestDocumentBlockType;
+    source: S.Union<[typeof Base64PDFSource, typeof PlainTextSource, typeof ContentBlockSource]>;
+    title: S.optionalWith<S.Union<[S.filter<S.Schema<string, string, never>>, typeof S.Null]>, {
+        nullable: true;
+    }>;
+    context: S.optionalWith<S.Union<[S.filter<S.Schema<string, string, never>>, typeof S.Null]>, {
+        nullable: true;
+    }>;
+    citations: S.optionalWith<typeof RequestCitationsConfig, {
+        nullable: true;
+    }>;
+}>;
+export declare class RequestDocumentBlock extends RequestDocumentBlock_base {
+}
+declare const InputContentBlock_base: S.Union<[typeof RequestTextBlock, typeof RequestImageBlock, typeof RequestToolUseBlock, typeof RequestToolResultBlock, typeof RequestDocumentBlock]>;
+export declare class InputContentBlock extends InputContentBlock_base {
+}
+declare const InputMessage_base: S.Struct<{
+    role: typeof InputMessageRole;
+    content: S.Union<[typeof S.String, S.Array$<typeof InputContentBlock>]>;
+}>;
+export declare class InputMessage extends InputMessage_base {
+}
+declare const Metadata_base: S.Struct<{
+    user_id: S.optionalWith<S.Union<[S.filter<S.Schema<string, string, never>>, typeof S.Null]>, {
+        nullable: true;
+    }>;
+}>;
+export declare class Metadata extends Metadata_base {
+}
+declare const ToolChoiceAutoType_base: S.Literal<["auto"]>;
+export declare class ToolChoiceAutoType extends ToolChoiceAutoType_base {
+}
+declare const ToolChoiceAuto_base: S.Struct<{
+    type: typeof ToolChoiceAutoType;
+    disable_parallel_tool_use: S.optionalWith<typeof S.Boolean, {
+        nullable: true;
+    }>;
+}>;
+export declare class ToolChoiceAuto extends ToolChoiceAuto_base {
+}
+declare const ToolChoiceAnyType_base: S.Literal<["any"]>;
+export declare class ToolChoiceAnyType extends ToolChoiceAnyType_base {
+}
+declare const ToolChoiceAny_base: S.Struct<{
+    type: typeof ToolChoiceAnyType;
+    disable_parallel_tool_use: S.optionalWith<typeof S.Boolean, {
+        nullable: true;
+    }>;
+}>;
+export declare class ToolChoiceAny extends ToolChoiceAny_base {
+}
+declare const ToolChoiceToolType_base: S.Literal<["tool"]>;
+export declare class ToolChoiceToolType extends ToolChoiceToolType_base {
+}
+declare const ToolChoiceTool_base: S.Struct<{
+    type: typeof ToolChoiceToolType;
+    name: typeof S.String;
+    disable_parallel_tool_use: S.optionalWith<typeof S.Boolean, {
+        nullable: true;
+    }>;
+}>;
+export declare class ToolChoiceTool extends ToolChoiceTool_base {
+}
+declare const ToolChoice_base: S.Union<[typeof ToolChoiceAuto, typeof ToolChoiceAny, typeof ToolChoiceTool]>;
+export declare class ToolChoice extends ToolChoice_base {
+}
+declare const InputSchemaType_base: S.Literal<["object"]>;
+export declare class InputSchemaType extends InputSchemaType_base {
+}
+declare const InputSchema_base: S.Struct<{
+    type: typeof InputSchemaType;
+    properties: S.optionalWith<S.Union<[S.Record$<typeof S.String, typeof S.Unknown>, typeof S.Null]>, {
+        nullable: true;
+    }>;
+}>;
+export declare class InputSchema extends InputSchema_base {
+}
+declare const Tool_base: S.Struct<{
+    description: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    name: S.filter<S.Schema<string, string, never>>;
+    input_schema: typeof InputSchema;
+    cache_control: S.optionalWith<S.Union<[typeof CacheControlEphemeral, typeof S.Null]>, {
+        nullable: true;
+    }>;
+}>;
+export declare class Tool extends Tool_base {
+}
+declare const CreateMessageParams_base: S.Class<CreateMessageParams, {
+    model: typeof Model;
+    messages: S.Array$<typeof InputMessage>;
+    max_tokens: S.filter<S.Schema<number, number, never>>;
+    metadata: S.optionalWith<typeof Metadata, {
+        nullable: true;
+    }>;
+    stop_sequences: S.optionalWith<S.Array$<typeof S.String>, {
+        nullable: true;
+    }>;
+    stream: S.optionalWith<typeof S.Boolean, {
+        nullable: true;
+    }>;
+    system: S.optionalWith<S.Union<[typeof S.String, S.Array$<typeof RequestTextBlock>]>, {
+        nullable: true;
+    }>;
+    temperature: S.optionalWith<S.filter<S.Schema<number, number, never>>, {
+        nullable: true;
+    }>;
+    tool_choice: S.optionalWith<typeof ToolChoice, {
+        nullable: true;
+    }>;
+    tools: S.optionalWith<S.Array$<typeof Tool>, {
+        nullable: true;
+    }>;
+    top_k: S.optionalWith<S.filter<S.Schema<number, number, never>>, {
+        nullable: true;
+    }>;
+    top_p: S.optionalWith<S.filter<S.Schema<number, number, never>>, {
+        nullable: true;
+    }>;
+}, S.Struct.Encoded<{
+    model: typeof Model;
+    messages: S.Array$<typeof InputMessage>;
+    max_tokens: S.filter<S.Schema<number, number, never>>;
+    metadata: S.optionalWith<typeof Metadata, {
+        nullable: true;
+    }>;
+    stop_sequences: S.optionalWith<S.Array$<typeof S.String>, {
+        nullable: true;
+    }>;
+    stream: S.optionalWith<typeof S.Boolean, {
+        nullable: true;
+    }>;
+    system: S.optionalWith<S.Union<[typeof S.String, S.Array$<typeof RequestTextBlock>]>, {
+        nullable: true;
+    }>;
+    temperature: S.optionalWith<S.filter<S.Schema<number, number, never>>, {
+        nullable: true;
+    }>;
+    tool_choice: S.optionalWith<typeof ToolChoice, {
+        nullable: true;
+    }>;
+    tools: S.optionalWith<S.Array$<typeof Tool>, {
+        nullable: true;
+    }>;
+    top_k: S.optionalWith<S.filter<S.Schema<number, number, never>>, {
+        nullable: true;
+    }>;
+    top_p: S.optionalWith<S.filter<S.Schema<number, number, never>>, {
+        nullable: true;
+    }>;
+}>, never, {
+    readonly model: string;
+} & {
+    readonly messages: readonly {
+        readonly content: string | readonly ({
+            readonly type: "text";
+            readonly text: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+            } | null | undefined;
+            readonly citations?: readonly ({
+                readonly type: "char_location";
+                readonly cited_text: string;
+                readonly document_index: number;
+                readonly document_title: string | null;
+                readonly start_char_index: number;
+                readonly end_char_index: number;
+            } | {
+                readonly type: "page_location";
+                readonly cited_text: string;
+                readonly document_index: number;
+                readonly document_title: string | null;
+                readonly start_page_number: number;
+                readonly end_page_number: number;
+            } | {
+                readonly type: "content_block_location";
+                readonly cited_text: string;
+                readonly document_index: number;
+                readonly document_title: string | null;
+                readonly start_block_index: number;
+                readonly end_block_index: number;
+            })[] | null | undefined;
+        } | {
+            readonly type: "image";
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+            } | null | undefined;
+            readonly source: {
+                readonly type: "base64";
+                readonly media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+                readonly data: string;
+            };
+        } | {
+            readonly type: "tool_use";
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+            } | null | undefined;
+            readonly id: string;
+            readonly name: string;
+            readonly input: {
+                readonly [x: string]: unknown;
+            };
+        } | {
+            readonly type: "tool_result";
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+            } | null | undefined;
+            readonly tool_use_id: string;
+            readonly is_error?: boolean | undefined;
+            readonly content?: string | readonly ({
+                readonly type: "text";
+                readonly text: string;
+                readonly cache_control?: {
+                    readonly type: "ephemeral";
+                } | null | undefined;
+                readonly citations?: readonly ({
+                    readonly type: "char_location";
+                    readonly cited_text: string;
+                    readonly document_index: number;
+                    readonly document_title: string | null;
+                    readonly start_char_index: number;
+                    readonly end_char_index: number;
+                } | {
+                    readonly type: "page_location";
+                    readonly cited_text: string;
+                    readonly document_index: number;
+                    readonly document_title: string | null;
+                    readonly start_page_number: number;
+                    readonly end_page_number: number;
+                } | {
+                    readonly type: "content_block_location";
+                    readonly cited_text: string;
+                    readonly document_index: number;
+                    readonly document_title: string | null;
+                    readonly start_block_index: number;
+                    readonly end_block_index: number;
+                })[] | null | undefined;
+            } | {
+                readonly type: "image";
+                readonly cache_control?: {
+                    readonly type: "ephemeral";
+                } | null | undefined;
+                readonly source: {
+                    readonly type: "base64";
+                    readonly media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+                    readonly data: string;
+                };
+            })[] | undefined;
+        } | {
+            readonly type: "document";
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+            } | null | undefined;
+            readonly citations?: {
+                readonly enabled?: boolean | undefined;
+            } | undefined;
+            readonly source: {
+                readonly type: "base64";
+                readonly media_type: "application/pdf";
+                readonly data: string;
+            } | {
+                readonly type: "text";
+                readonly media_type: "text/plain";
+                readonly data: string;
+            } | {
+                readonly type: "content";
+                readonly content: string | readonly ({
+                    readonly type: "text";
+                    readonly text: string;
+                    readonly cache_control?: {
+                        readonly type: "ephemeral";
+                    } | null | undefined;
+                    readonly citations?: readonly ({
+                        readonly type: "char_location";
+                        readonly cited_text: string;
+                        readonly document_index: number;
+                        readonly document_title: string | null;
+                        readonly start_char_index: number;
+                        readonly end_char_index: number;
+                    } | {
+                        readonly type: "page_location";
+                        readonly cited_text: string;
+                        readonly document_index: number;
+                        readonly document_title: string | null;
+                        readonly start_page_number: number;
+                        readonly end_page_number: number;
+                    } | {
+                        readonly type: "content_block_location";
+                        readonly cited_text: string;
+                        readonly document_index: number;
+                        readonly document_title: string | null;
+                        readonly start_block_index: number;
+                        readonly end_block_index: number;
+                    })[] | null | undefined;
+                } | {
+                    readonly type: "image";
+                    readonly cache_control?: {
+                        readonly type: "ephemeral";
+                    } | null | undefined;
+                    readonly source: {
+                        readonly type: "base64";
+                        readonly media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+                        readonly data: string;
+                    };
+                })[];
+            };
+            readonly title?: string | null | undefined;
+            readonly context?: string | null | undefined;
+        })[];
+        readonly role: "user" | "assistant";
+    }[];
+} & {
+    readonly max_tokens: number;
+} & {
+    readonly metadata?: {
+        readonly user_id?: string | null | undefined;
+    } | undefined;
+} & {
+    readonly stop_sequences?: readonly string[] | undefined;
+} & {
+    readonly stream?: boolean | undefined;
+} & {
+    readonly system?: string | readonly {
+        readonly type: "text";
+        readonly text: string;
+        readonly cache_control?: {
+            readonly type: "ephemeral";
+        } | null | undefined;
+        readonly citations?: readonly ({
+            readonly type: "char_location";
+            readonly cited_text: string;
+            readonly document_index: number;
+            readonly document_title: string | null;
+            readonly start_char_index: number;
+            readonly end_char_index: number;
+        } | {
+            readonly type: "page_location";
+            readonly cited_text: string;
+            readonly document_index: number;
+            readonly document_title: string | null;
+            readonly start_page_number: number;
+            readonly end_page_number: number;
+        } | {
+            readonly type: "content_block_location";
+            readonly cited_text: string;
+            readonly document_index: number;
+            readonly document_title: string | null;
+            readonly start_block_index: number;
+            readonly end_block_index: number;
+        })[] | null | undefined;
+    }[] | undefined;
+} & {
+    readonly temperature?: number | undefined;
+} & {
+    readonly tool_choice?: {
+        readonly type: "auto";
+        readonly disable_parallel_tool_use?: boolean | undefined;
+    } | {
+        readonly type: "any";
+        readonly disable_parallel_tool_use?: boolean | undefined;
+    } | {
+        readonly type: "tool";
+        readonly name: string;
+        readonly disable_parallel_tool_use?: boolean | undefined;
+    } | undefined;
+} & {
+    readonly tools?: readonly {
+        readonly cache_control?: {
+            readonly type: "ephemeral";
+        } | null | undefined;
+        readonly name: string;
+        readonly description?: string | undefined;
+        readonly input_schema: {
+            readonly type: "object";
+            readonly properties?: {
+                readonly [x: string]: unknown;
+            } | null | undefined;
+        };
+    }[] | undefined;
+} & {
+    readonly top_k?: number | undefined;
+} & {
+    readonly top_p?: number | undefined;
+}, {}, {}>;
+export declare class CreateMessageParams extends CreateMessageParams_base {
+}
+declare const MessageType_base: S.Literal<["message"]>;
+export declare class MessageType extends MessageType_base {
+}
+declare const MessageRole_base: S.Literal<["assistant"]>;
+export declare class MessageRole extends MessageRole_base {
+}
+declare const ResponseTextBlockType_base: S.Literal<["text"]>;
+export declare class ResponseTextBlockType extends ResponseTextBlockType_base {
+}
+declare const ResponseCharLocationCitationType_base: S.Literal<["char_location"]>;
+export declare class ResponseCharLocationCitationType extends ResponseCharLocationCitationType_base {
+}
+declare const ResponseCharLocationCitation_base: S.Struct<{
+    type: S.PropertySignature<":", "char_location", never, ":", "char_location", true, never>;
+    cited_text: typeof S.String;
+    document_index: S.filter<S.Schema<number, number, never>>;
+    document_title: S.Union<[typeof S.String, typeof S.Null]>;
+    start_char_index: S.filter<S.Schema<number, number, never>>;
+    end_char_index: typeof S.Int;
+}>;
+export declare class ResponseCharLocationCitation extends ResponseCharLocationCitation_base {
+}
+declare const ResponsePageLocationCitationType_base: S.Literal<["page_location"]>;
+export declare class ResponsePageLocationCitationType extends ResponsePageLocationCitationType_base {
+}
+declare const ResponsePageLocationCitation_base: S.Struct<{
+    type: S.PropertySignature<":", "page_location", never, ":", "page_location", true, never>;
+    cited_text: typeof S.String;
+    document_index: S.filter<S.Schema<number, number, never>>;
+    document_title: S.Union<[typeof S.String, typeof S.Null]>;
+    start_page_number: S.filter<S.Schema<number, number, never>>;
+    end_page_number: typeof S.Int;
+}>;
+export declare class ResponsePageLocationCitation extends ResponsePageLocationCitation_base {
+}
+declare const ResponseContentBlockLocationCitationType_base: S.Literal<["content_block_location"]>;
+export declare class ResponseContentBlockLocationCitationType extends ResponseContentBlockLocationCitationType_base {
+}
+declare const ResponseContentBlockLocationCitation_base: S.Struct<{
+    type: S.PropertySignature<":", "content_block_location", never, ":", "content_block_location", true, never>;
+    cited_text: typeof S.String;
+    document_index: S.filter<S.Schema<number, number, never>>;
+    document_title: S.Union<[typeof S.String, typeof S.Null]>;
+    start_block_index: S.filter<S.Schema<number, number, never>>;
+    end_block_index: typeof S.Int;
+}>;
+export declare class ResponseContentBlockLocationCitation extends ResponseContentBlockLocationCitation_base {
+}
+declare const ResponseTextBlock_base: S.Struct<{
+    type: S.PropertySignature<":", "text", never, ":", "text", true, never>;
+    text: S.filter<S.Schema<string, string, never>>;
+    citations: S.optionalWith<S.NullOr<S.Union<[S.Array$<S.Union<[typeof ResponseCharLocationCitation, typeof ResponsePageLocationCitation, typeof ResponseContentBlockLocationCitation]>>, typeof S.Null]>>, {
+        default: () => null;
+    }>;
+}>;
+export declare class ResponseTextBlock extends ResponseTextBlock_base {
+}
+declare const ResponseToolUseBlockType_base: S.Literal<["tool_use"]>;
+export declare class ResponseToolUseBlockType extends ResponseToolUseBlockType_base {
+}
+declare const ResponseToolUseBlock_base: S.Struct<{
+    type: S.PropertySignature<":", "tool_use", never, ":", "tool_use", true, never>;
+    id: S.filter<S.Schema<string, string, never>>;
+    name: S.filter<S.Schema<string, string, never>>;
+    input: S.Record$<typeof S.String, typeof S.Unknown>;
+}>;
+export declare class ResponseToolUseBlock extends ResponseToolUseBlock_base {
+}
+declare const ContentBlock_base: S.Union<[typeof ResponseTextBlock, typeof ResponseToolUseBlock]>;
+export declare class ContentBlock extends ContentBlock_base {
+}
+declare const MessageStopReasonEnum_base: S.Literal<["end_turn", "max_tokens", "stop_sequence", "tool_use"]>;
+export declare class MessageStopReasonEnum extends MessageStopReasonEnum_base {
+}
+declare const Usage_base: S.Struct<{
+    input_tokens: S.filter<S.Schema<number, number, never>>;
+    cache_creation_input_tokens: S.optionalWith<S.NullOr<S.Union<[S.filter<S.Schema<number, number, never>>, typeof S.Null]>>, {
+        default: () => null;
+    }>;
+    cache_read_input_tokens: S.optionalWith<S.NullOr<S.Union<[S.filter<S.Schema<number, number, never>>, typeof S.Null]>>, {
+        default: () => null;
+    }>;
+    output_tokens: S.filter<S.Schema<number, number, never>>;
+}>;
+export declare class Usage extends Usage_base {
+}
+declare const Message_base: S.Class<Message, {
+    id: typeof S.String;
+    type: S.PropertySignature<":", "message", never, ":", "message", true, never>;
+    role: S.PropertySignature<":", "assistant", never, ":", "assistant", true, never>;
+    content: S.Array$<typeof ContentBlock>;
+    model: typeof Model;
+    stop_reason: S.Union<[typeof MessageStopReasonEnum, typeof S.Null]>;
+    stop_sequence: S.optionalWith<S.NullOr<S.Union<[typeof S.String, typeof S.Null]>>, {
+        default: () => null;
+    }>;
+    usage: typeof Usage;
+}, S.Struct.Encoded<{
+    id: typeof S.String;
+    type: S.PropertySignature<":", "message", never, ":", "message", true, never>;
+    role: S.PropertySignature<":", "assistant", never, ":", "assistant", true, never>;
+    content: S.Array$<typeof ContentBlock>;
+    model: typeof Model;
+    stop_reason: S.Union<[typeof MessageStopReasonEnum, typeof S.Null]>;
+    stop_sequence: S.optionalWith<S.NullOr<S.Union<[typeof S.String, typeof S.Null]>>, {
+        default: () => null;
+    }>;
+    usage: typeof Usage;
+}>, never, {
+    readonly type?: "message" | undefined;
+} & {
+    readonly id: string;
+} & {
+    readonly content: readonly ({
+        readonly type: "text";
+        readonly text: string;
+        readonly citations: readonly ({
+            readonly type: "char_location";
+            readonly cited_text: string;
+            readonly document_index: number;
+            readonly document_title: string | null;
+            readonly start_char_index: number;
+            readonly end_char_index: number;
+        } | {
+            readonly type: "page_location";
+            readonly cited_text: string;
+            readonly document_index: number;
+            readonly document_title: string | null;
+            readonly start_page_number: number;
+            readonly end_page_number: number;
+        } | {
+            readonly type: "content_block_location";
+            readonly cited_text: string;
+            readonly document_index: number;
+            readonly document_title: string | null;
+            readonly start_block_index: number;
+            readonly end_block_index: number;
+        })[] | null;
+    } | {
+        readonly type: "tool_use";
+        readonly id: string;
+        readonly name: string;
+        readonly input: {
+            readonly [x: string]: unknown;
+        };
+    })[];
+} & {
+    readonly role?: "assistant" | undefined;
+} & {
+    readonly model: string;
+} & {
+    readonly stop_sequence?: string | null | undefined;
+} & {
+    readonly usage: {
+        readonly input_tokens: number;
+        readonly cache_creation_input_tokens: number | null;
+        readonly cache_read_input_tokens: number | null;
+        readonly output_tokens: number;
+    };
+} & {
+    readonly stop_reason: "tool_use" | "max_tokens" | "end_turn" | "stop_sequence" | null;
+}, {}, {}>;
+export declare class Message extends Message_base {
+}
+declare const ErrorResponseType_base: S.Literal<["error"]>;
+export declare class ErrorResponseType extends ErrorResponseType_base {
+}
+declare const InvalidRequestErrorType_base: S.Literal<["invalid_request_error"]>;
+export declare class InvalidRequestErrorType extends InvalidRequestErrorType_base {
+}
+declare const InvalidRequestError_base: S.Struct<{
+    type: S.PropertySignature<":", "invalid_request_error", never, ":", "invalid_request_error", true, never>;
+    message: S.PropertySignature<":", string, never, ":", string, true, never>;
+}>;
+export declare class InvalidRequestError extends InvalidRequestError_base {
+}
+declare const AuthenticationErrorType_base: S.Literal<["authentication_error"]>;
+export declare class AuthenticationErrorType extends AuthenticationErrorType_base {
+}
+declare const AuthenticationError_base: S.Struct<{
+    type: S.PropertySignature<":", "authentication_error", never, ":", "authentication_error", true, never>;
+    message: S.PropertySignature<":", string, never, ":", string, true, never>;
+}>;
+export declare class AuthenticationError extends AuthenticationError_base {
+}
+declare const BillingErrorType_base: S.Literal<["billing_error"]>;
+export declare class BillingErrorType extends BillingErrorType_base {
+}
+declare const BillingError_base: S.Struct<{
+    type: S.PropertySignature<":", "billing_error", never, ":", "billing_error", true, never>;
+    message: S.PropertySignature<":", string, never, ":", string, true, never>;
+}>;
+export declare class BillingError extends BillingError_base {
+}
+declare const PermissionErrorType_base: S.Literal<["permission_error"]>;
+export declare class PermissionErrorType extends PermissionErrorType_base {
+}
+declare const PermissionError_base: S.Struct<{
+    type: S.PropertySignature<":", "permission_error", never, ":", "permission_error", true, never>;
+    message: S.PropertySignature<":", string, never, ":", string, true, never>;
+}>;
+export declare class PermissionError extends PermissionError_base {
+}
+declare const NotFoundErrorType_base: S.Literal<["not_found_error"]>;
+export declare class NotFoundErrorType extends NotFoundErrorType_base {
+}
+declare const NotFoundError_base: S.Struct<{
+    type: S.PropertySignature<":", "not_found_error", never, ":", "not_found_error", true, never>;
+    message: S.PropertySignature<":", string, never, ":", string, true, never>;
+}>;
+export declare class NotFoundError extends NotFoundError_base {
+}
+declare const RateLimitErrorType_base: S.Literal<["rate_limit_error"]>;
+export declare class RateLimitErrorType extends RateLimitErrorType_base {
+}
+declare const RateLimitError_base: S.Struct<{
+    type: S.PropertySignature<":", "rate_limit_error", never, ":", "rate_limit_error", true, never>;
+    message: S.PropertySignature<":", string, never, ":", string, true, never>;
+}>;
+export declare class RateLimitError extends RateLimitError_base {
+}
+declare const GatewayTimeoutErrorType_base: S.Literal<["timeout_error"]>;
+export declare class GatewayTimeoutErrorType extends GatewayTimeoutErrorType_base {
+}
+declare const GatewayTimeoutError_base: S.Struct<{
+    type: S.PropertySignature<":", "timeout_error", never, ":", "timeout_error", true, never>;
+    message: S.PropertySignature<":", string, never, ":", string, true, never>;
+}>;
+export declare class GatewayTimeoutError extends GatewayTimeoutError_base {
+}
+declare const APIErrorType_base: S.Literal<["api_error"]>;
+export declare class APIErrorType extends APIErrorType_base {
+}
+declare const APIError_base: S.Struct<{
+    type: S.PropertySignature<":", "api_error", never, ":", "api_error", true, never>;
+    message: S.PropertySignature<":", string, never, ":", string, true, never>;
+}>;
+export declare class APIError extends APIError_base {
+}
+declare const OverloadedErrorType_base: S.Literal<["overloaded_error"]>;
+export declare class OverloadedErrorType extends OverloadedErrorType_base {
+}
+declare const OverloadedError_base: S.Struct<{
+    type: S.PropertySignature<":", "overloaded_error", never, ":", "overloaded_error", true, never>;
+    message: S.PropertySignature<":", string, never, ":", string, true, never>;
+}>;
+export declare class OverloadedError extends OverloadedError_base {
+}
+declare const ErrorResponse_base: S.Class<ErrorResponse, {
+    type: S.PropertySignature<":", "error", never, ":", "error", true, never>;
+    error: S.Union<[typeof InvalidRequestError, typeof AuthenticationError, typeof BillingError, typeof PermissionError, typeof NotFoundError, typeof RateLimitError, typeof GatewayTimeoutError, typeof APIError, typeof OverloadedError]>;
+}, S.Struct.Encoded<{
+    type: S.PropertySignature<":", "error", never, ":", "error", true, never>;
+    error: S.Union<[typeof InvalidRequestError, typeof AuthenticationError, typeof BillingError, typeof PermissionError, typeof NotFoundError, typeof RateLimitError, typeof GatewayTimeoutError, typeof APIError, typeof OverloadedError]>;
+}>, never, {
+    readonly type?: "error" | undefined;
+} & {
+    readonly error: {
+        readonly type: "invalid_request_error";
+        readonly message: string;
+    } | {
+        readonly type: "authentication_error";
+        readonly message: string;
+    } | {
+        readonly type: "billing_error";
+        readonly message: string;
+    } | {
+        readonly type: "permission_error";
+        readonly message: string;
+    } | {
+        readonly type: "not_found_error";
+        readonly message: string;
+    } | {
+        readonly type: "rate_limit_error";
+        readonly message: string;
+    } | {
+        readonly type: "timeout_error";
+        readonly message: string;
+    } | {
+        readonly type: "api_error";
+        readonly message: string;
+    } | {
+        readonly type: "overloaded_error";
+        readonly message: string;
+    };
+}, {}, {}>;
+export declare class ErrorResponse extends ErrorResponse_base {
+}
+declare const CompletePostParams_base: S.Struct<{
+    "anthropic-version": S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+}>;
+export declare class CompletePostParams extends CompletePostParams_base {
+}
+declare const CompletionRequest_base: S.Class<CompletionRequest, {
+    model: typeof Model;
+    prompt: S.filter<S.Schema<string, string, never>>;
+    max_tokens_to_sample: S.filter<S.Schema<number, number, never>>;
+    stop_sequences: S.optionalWith<S.Array$<typeof S.String>, {
+        nullable: true;
+    }>;
+    temperature: S.optionalWith<S.filter<S.Schema<number, number, never>>, {
+        nullable: true;
+    }>;
+    top_p: S.optionalWith<S.filter<S.Schema<number, number, never>>, {
+        nullable: true;
+    }>;
+    top_k: S.optionalWith<S.filter<S.Schema<number, number, never>>, {
+        nullable: true;
+    }>;
+    metadata: S.optionalWith<typeof Metadata, {
+        nullable: true;
+    }>;
+    stream: S.optionalWith<typeof S.Boolean, {
+        nullable: true;
+    }>;
+}, S.Struct.Encoded<{
+    model: typeof Model;
+    prompt: S.filter<S.Schema<string, string, never>>;
+    max_tokens_to_sample: S.filter<S.Schema<number, number, never>>;
+    stop_sequences: S.optionalWith<S.Array$<typeof S.String>, {
+        nullable: true;
+    }>;
+    temperature: S.optionalWith<S.filter<S.Schema<number, number, never>>, {
+        nullable: true;
+    }>;
+    top_p: S.optionalWith<S.filter<S.Schema<number, number, never>>, {
+        nullable: true;
+    }>;
+    top_k: S.optionalWith<S.filter<S.Schema<number, number, never>>, {
+        nullable: true;
+    }>;
+    metadata: S.optionalWith<typeof Metadata, {
+        nullable: true;
+    }>;
+    stream: S.optionalWith<typeof S.Boolean, {
+        nullable: true;
+    }>;
+}>, never, {
+    readonly model: string;
+} & {
+    readonly metadata?: {
+        readonly user_id?: string | null | undefined;
+    } | undefined;
+} & {
+    readonly stop_sequences?: readonly string[] | undefined;
+} & {
+    readonly stream?: boolean | undefined;
+} & {
+    readonly temperature?: number | undefined;
+} & {
+    readonly top_k?: number | undefined;
+} & {
+    readonly top_p?: number | undefined;
+} & {
+    readonly prompt: string;
+} & {
+    readonly max_tokens_to_sample: number;
+}, {}, {}>;
+export declare class CompletionRequest extends CompletionRequest_base {
+}
+declare const CompletionResponseType_base: S.Literal<["completion"]>;
+export declare class CompletionResponseType extends CompletionResponseType_base {
+}
+declare const CompletionResponse_base: S.Class<CompletionResponse, {
+    type: S.PropertySignature<":", "completion", never, ":", "completion", true, never>;
+    id: typeof S.String;
+    completion: typeof S.String;
+    stop_reason: S.Union<[typeof S.String, typeof S.Null]>;
+    model: typeof Model;
+}, S.Struct.Encoded<{
+    type: S.PropertySignature<":", "completion", never, ":", "completion", true, never>;
+    id: typeof S.String;
+    completion: typeof S.String;
+    stop_reason: S.Union<[typeof S.String, typeof S.Null]>;
+    model: typeof Model;
+}>, never, {
+    readonly type?: "completion" | undefined;
+} & {
+    readonly id: string;
+} & {
+    readonly model: string;
+} & {
+    readonly stop_reason: string | null;
+} & {
+    readonly completion: string;
+}, {}, {}>;
+export declare class CompletionResponse extends CompletionResponse_base {
+}
+declare const ModelsListParams_base: S.Struct<{
+    before_id: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    after_id: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    limit: S.optionalWith<S.filter<S.Schema<number, number, never>>, {
+        nullable: true;
+        default: () => 20;
+    }>;
+    "anthropic-version": S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    "x-api-key": S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+}>;
+export declare class ModelsListParams extends ModelsListParams_base {
+}
+declare const ModelInfoType_base: S.Literal<["model"]>;
+export declare class ModelInfoType extends ModelInfoType_base {
+}
+declare const ModelInfo_base: S.Struct<{
+    type: S.PropertySignature<":", "model", never, ":", "model", true, never>;
+    id: typeof S.String;
+    display_name: typeof S.String;
+    created_at: typeof S.String;
+}>;
+export declare class ModelInfo extends ModelInfo_base {
+}
+declare const ListResponseModelInfo_base: S.Class<ListResponseModelInfo, {
+    data: S.Array$<typeof ModelInfo>;
+    has_more: typeof S.Boolean;
+    first_id: S.Union<[typeof S.String, typeof S.Null]>;
+    last_id: S.Union<[typeof S.String, typeof S.Null]>;
+}, S.Struct.Encoded<{
+    data: S.Array$<typeof ModelInfo>;
+    has_more: typeof S.Boolean;
+    first_id: S.Union<[typeof S.String, typeof S.Null]>;
+    last_id: S.Union<[typeof S.String, typeof S.Null]>;
+}>, never, {
+    readonly data: readonly {
+        readonly type: "model";
+        readonly id: string;
+        readonly display_name: string;
+        readonly created_at: string;
+    }[];
+} & {
+    readonly has_more: boolean;
+} & {
+    readonly first_id: string | null;
+} & {
+    readonly last_id: string | null;
+}, {}, {}>;
+export declare class ListResponseModelInfo extends ListResponseModelInfo_base {
+}
+declare const ModelsGetParams_base: S.Struct<{
+    "anthropic-version": S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    "x-api-key": S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+}>;
+export declare class ModelsGetParams extends ModelsGetParams_base {
+}
+declare const MessageBatchesListParams_base: S.Struct<{
+    before_id: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    after_id: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    limit: S.optionalWith<S.filter<S.Schema<number, number, never>>, {
+        nullable: true;
+        default: () => 20;
+    }>;
+    "anthropic-version": S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    "x-api-key": S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+}>;
+export declare class MessageBatchesListParams extends MessageBatchesListParams_base {
+}
+declare const MessageBatchType_base: S.Literal<["message_batch"]>;
+export declare class MessageBatchType extends MessageBatchType_base {
+}
+declare const MessageBatchProcessingStatus_base: S.Literal<["in_progress", "canceling", "ended"]>;
+export declare class MessageBatchProcessingStatus extends MessageBatchProcessingStatus_base {
+}
+declare const RequestCounts_base: S.Struct<{
+    processing: S.PropertySignature<":", number, never, ":", number, true, never>;
+    succeeded: S.PropertySignature<":", number, never, ":", number, true, never>;
+    errored: S.PropertySignature<":", number, never, ":", number, true, never>;
+    canceled: S.PropertySignature<":", number, never, ":", number, true, never>;
+    expired: S.PropertySignature<":", number, never, ":", number, true, never>;
+}>;
+export declare class RequestCounts extends RequestCounts_base {
+}
+declare const MessageBatch_base: S.Struct<{
+    id: typeof S.String;
+    type: S.PropertySignature<":", "message_batch", never, ":", "message_batch", true, never>;
+    processing_status: typeof MessageBatchProcessingStatus;
+    request_counts: typeof RequestCounts;
+    ended_at: S.Union<[typeof S.String, typeof S.Null]>;
+    created_at: typeof S.String;
+    expires_at: typeof S.String;
+    archived_at: S.Union<[typeof S.String, typeof S.Null]>;
+    cancel_initiated_at: S.Union<[typeof S.String, typeof S.Null]>;
+    results_url: S.Union<[typeof S.String, typeof S.Null]>;
+}>;
+export declare class MessageBatch extends MessageBatch_base {
+}
+declare const ListResponseMessageBatch_base: S.Class<ListResponseMessageBatch, {
+    data: S.Array$<typeof MessageBatch>;
+    has_more: typeof S.Boolean;
+    first_id: S.Union<[typeof S.String, typeof S.Null]>;
+    last_id: S.Union<[typeof S.String, typeof S.Null]>;
+}, S.Struct.Encoded<{
+    data: S.Array$<typeof MessageBatch>;
+    has_more: typeof S.Boolean;
+    first_id: S.Union<[typeof S.String, typeof S.Null]>;
+    last_id: S.Union<[typeof S.String, typeof S.Null]>;
+}>, never, {
+    readonly data: readonly {
+        readonly type: "message_batch";
+        readonly id: string;
+        readonly created_at: string;
+        readonly processing_status: "in_progress" | "canceling" | "ended";
+        readonly request_counts: {
+            readonly processing: number;
+            readonly succeeded: number;
+            readonly errored: number;
+            readonly canceled: number;
+            readonly expired: number;
+        };
+        readonly ended_at: string | null;
+        readonly expires_at: string;
+        readonly archived_at: string | null;
+        readonly cancel_initiated_at: string | null;
+        readonly results_url: string | null;
+    }[];
+} & {
+    readonly has_more: boolean;
+} & {
+    readonly first_id: string | null;
+} & {
+    readonly last_id: string | null;
+}, {}, {}>;
+export declare class ListResponseMessageBatch extends ListResponseMessageBatch_base {
+}
+declare const MessageBatchesPostParams_base: S.Struct<{
+    "anthropic-version": S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+}>;
+export declare class MessageBatchesPostParams extends MessageBatchesPostParams_base {
+}
+declare const MessageBatchIndividualRequestParams_base: S.Struct<{
+    custom_id: S.filter<S.Schema<string, string, never>>;
+    params: typeof CreateMessageParams;
+}>;
+export declare class MessageBatchIndividualRequestParams extends MessageBatchIndividualRequestParams_base {
+}
+declare const CreateMessageBatchParams_base: S.Class<CreateMessageBatchParams, {
+    requests: S.filter<S.Schema<readonly {
+        readonly custom_id: string;
+        readonly params: CreateMessageParams;
+    }[], readonly {
+        readonly custom_id: string;
+        readonly params: {
+            readonly model: string;
+            readonly messages: readonly {
+                readonly content: string | readonly ({
+                    readonly type: "text";
+                    readonly text: string;
+                    readonly cache_control?: {
+                        readonly type: "ephemeral";
+                    } | null | undefined;
+                    readonly citations?: readonly ({
+                        readonly type: "char_location";
+                        readonly cited_text: string;
+                        readonly document_index: number;
+                        readonly document_title: string | null;
+                        readonly start_char_index: number;
+                        readonly end_char_index: number;
+                    } | {
+                        readonly type: "page_location";
+                        readonly cited_text: string;
+                        readonly document_index: number;
+                        readonly document_title: string | null;
+                        readonly start_page_number: number;
+                        readonly end_page_number: number;
+                    } | {
+                        readonly type: "content_block_location";
+                        readonly cited_text: string;
+                        readonly document_index: number;
+                        readonly document_title: string | null;
+                        readonly start_block_index: number;
+                        readonly end_block_index: number;
+                    })[] | null | undefined;
+                } | {
+                    readonly type: "image";
+                    readonly source: {
+                        readonly type: "base64";
+                        readonly media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+                        readonly data: string;
+                    };
+                    readonly cache_control?: {
+                        readonly type: "ephemeral";
+                    } | null | undefined;
+                } | {
+                    readonly type: "tool_use";
+                    readonly id: string;
+                    readonly name: string;
+                    readonly input: {
+                        readonly [x: string]: unknown;
+                    };
+                    readonly cache_control?: {
+                        readonly type: "ephemeral";
+                    } | null | undefined;
+                } | {
+                    readonly type: "tool_result";
+                    readonly tool_use_id: string;
+                    readonly cache_control?: {
+                        readonly type: "ephemeral";
+                    } | null | undefined;
+                    readonly is_error?: boolean | null | undefined;
+                    readonly content?: string | readonly ({
+                        readonly type: "text";
+                        readonly text: string;
+                        readonly cache_control?: {
+                            readonly type: "ephemeral";
+                        } | null | undefined;
+                        readonly citations?: readonly ({
+                            readonly type: "char_location";
+                            readonly cited_text: string;
+                            readonly document_index: number;
+                            readonly document_title: string | null;
+                            readonly start_char_index: number;
+                            readonly end_char_index: number;
+                        } | {
+                            readonly type: "page_location";
+                            readonly cited_text: string;
+                            readonly document_index: number;
+                            readonly document_title: string | null;
+                            readonly start_page_number: number;
+                            readonly end_page_number: number;
+                        } | {
+                            readonly type: "content_block_location";
+                            readonly cited_text: string;
+                            readonly document_index: number;
+                            readonly document_title: string | null;
+                            readonly start_block_index: number;
+                            readonly end_block_index: number;
+                        })[] | null | undefined;
+                    } | {
+                        readonly type: "image";
+                        readonly source: {
+                            readonly type: "base64";
+                            readonly media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+                            readonly data: string;
+                        };
+                        readonly cache_control?: {
+                            readonly type: "ephemeral";
+                        } | null | undefined;
+                    })[] | null | undefined;
+                } | {
+                    readonly type: "document";
+                    readonly source: {
+                        readonly type: "base64";
+                        readonly media_type: "application/pdf";
+                        readonly data: string;
+                    } | {
+                        readonly type: "text";
+                        readonly media_type: "text/plain";
+                        readonly data: string;
+                    } | {
+                        readonly type: "content";
+                        readonly content: string | readonly ({
+                            readonly type: "text";
+                            readonly text: string;
+                            readonly cache_control?: {
+                                readonly type: "ephemeral";
+                            } | null | undefined;
+                            readonly citations?: readonly ({
+                                readonly type: "char_location";
+                                readonly cited_text: string;
+                                readonly document_index: number;
+                                readonly document_title: string | null;
+                                readonly start_char_index: number;
+                                readonly end_char_index: number;
+                            } | {
+                                readonly type: "page_location";
+                                readonly cited_text: string;
+                                readonly document_index: number;
+                                readonly document_title: string | null;
+                                readonly start_page_number: number;
+                                readonly end_page_number: number;
+                            } | {
+                                readonly type: "content_block_location";
+                                readonly cited_text: string;
+                                readonly document_index: number;
+                                readonly document_title: string | null;
+                                readonly start_block_index: number;
+                                readonly end_block_index: number;
+                            })[] | null | undefined;
+                        } | {
+                            readonly type: "image";
+                            readonly source: {
+                                readonly type: "base64";
+                                readonly media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+                                readonly data: string;
+                            };
+                            readonly cache_control?: {
+                                readonly type: "ephemeral";
+                            } | null | undefined;
+                        })[];
+                    };
+                    readonly cache_control?: {
+                        readonly type: "ephemeral";
+                    } | null | undefined;
+                    readonly citations?: {
+                        readonly enabled?: boolean | null | undefined;
+                    } | null | undefined;
+                    readonly title?: string | null | undefined;
+                    readonly context?: string | null | undefined;
+                })[];
+                readonly role: "user" | "assistant";
+            }[];
+            readonly max_tokens: number;
+            readonly metadata?: {
+                readonly user_id?: string | null | undefined;
+            } | null | undefined;
+            readonly stop_sequences?: readonly string[] | null | undefined;
+            readonly stream?: boolean | null | undefined;
+            readonly system?: string | readonly {
+                readonly type: "text";
+                readonly text: string;
+                readonly cache_control?: {
+                    readonly type: "ephemeral";
+                } | null | undefined;
+                readonly citations?: readonly ({
+                    readonly type: "char_location";
+                    readonly cited_text: string;
+                    readonly document_index: number;
+                    readonly document_title: string | null;
+                    readonly start_char_index: number;
+                    readonly end_char_index: number;
+                } | {
+                    readonly type: "page_location";
+                    readonly cited_text: string;
+                    readonly document_index: number;
+                    readonly document_title: string | null;
+                    readonly start_page_number: number;
+                    readonly end_page_number: number;
+                } | {
+                    readonly type: "content_block_location";
+                    readonly cited_text: string;
+                    readonly document_index: number;
+                    readonly document_title: string | null;
+                    readonly start_block_index: number;
+                    readonly end_block_index: number;
+                })[] | null | undefined;
+            }[] | null | undefined;
+            readonly temperature?: number | null | undefined;
+            readonly tool_choice?: {
+                readonly type: "auto";
+                readonly disable_parallel_tool_use?: boolean | null | undefined;
+            } | {
+                readonly type: "any";
+                readonly disable_parallel_tool_use?: boolean | null | undefined;
+            } | {
+                readonly type: "tool";
+                readonly name: string;
+                readonly disable_parallel_tool_use?: boolean | null | undefined;
+            } | null | undefined;
+            readonly tools?: readonly {
+                readonly name: string;
+                readonly input_schema: {
+                    readonly type: "object";
+                    readonly properties?: {
+                        readonly [x: string]: unknown;
+                    } | null | undefined;
+                };
+                readonly cache_control?: {
+                    readonly type: "ephemeral";
+                } | null | undefined;
+                readonly description?: string | null | undefined;
+            }[] | null | undefined;
+            readonly top_k?: number | null | undefined;
+            readonly top_p?: number | null | undefined;
+        };
+    }[], never>>;
+}, S.Struct.Encoded<{
+    requests: S.filter<S.Schema<readonly {
+        readonly custom_id: string;
+        readonly params: CreateMessageParams;
+    }[], readonly {
+        readonly custom_id: string;
+        readonly params: {
+            readonly model: string;
+            readonly messages: readonly {
+                readonly content: string | readonly ({
+                    readonly type: "text";
+                    readonly text: string;
+                    readonly cache_control?: {
+                        readonly type: "ephemeral";
+                    } | null | undefined;
+                    readonly citations?: readonly ({
+                        readonly type: "char_location";
+                        readonly cited_text: string;
+                        readonly document_index: number;
+                        readonly document_title: string | null;
+                        readonly start_char_index: number;
+                        readonly end_char_index: number;
+                    } | {
+                        readonly type: "page_location";
+                        readonly cited_text: string;
+                        readonly document_index: number;
+                        readonly document_title: string | null;
+                        readonly start_page_number: number;
+                        readonly end_page_number: number;
+                    } | {
+                        readonly type: "content_block_location";
+                        readonly cited_text: string;
+                        readonly document_index: number;
+                        readonly document_title: string | null;
+                        readonly start_block_index: number;
+                        readonly end_block_index: number;
+                    })[] | null | undefined;
+                } | {
+                    readonly type: "image";
+                    readonly source: {
+                        readonly type: "base64";
+                        readonly media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+                        readonly data: string;
+                    };
+                    readonly cache_control?: {
+                        readonly type: "ephemeral";
+                    } | null | undefined;
+                } | {
+                    readonly type: "tool_use";
+                    readonly id: string;
+                    readonly name: string;
+                    readonly input: {
+                        readonly [x: string]: unknown;
+                    };
+                    readonly cache_control?: {
+                        readonly type: "ephemeral";
+                    } | null | undefined;
+                } | {
+                    readonly type: "tool_result";
+                    readonly tool_use_id: string;
+                    readonly cache_control?: {
+                        readonly type: "ephemeral";
+                    } | null | undefined;
+                    readonly is_error?: boolean | null | undefined;
+                    readonly content?: string | readonly ({
+                        readonly type: "text";
+                        readonly text: string;
+                        readonly cache_control?: {
+                            readonly type: "ephemeral";
+                        } | null | undefined;
+                        readonly citations?: readonly ({
+                            readonly type: "char_location";
+                            readonly cited_text: string;
+                            readonly document_index: number;
+                            readonly document_title: string | null;
+                            readonly start_char_index: number;
+                            readonly end_char_index: number;
+                        } | {
+                            readonly type: "page_location";
+                            readonly cited_text: string;
+                            readonly document_index: number;
+                            readonly document_title: string | null;
+                            readonly start_page_number: number;
+                            readonly end_page_number: number;
+                        } | {
+                            readonly type: "content_block_location";
+                            readonly cited_text: string;
+                            readonly document_index: number;
+                            readonly document_title: string | null;
+                            readonly start_block_index: number;
+                            readonly end_block_index: number;
+                        })[] | null | undefined;
+                    } | {
+                        readonly type: "image";
+                        readonly source: {
+                            readonly type: "base64";
+                            readonly media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+                            readonly data: string;
+                        };
+                        readonly cache_control?: {
+                            readonly type: "ephemeral";
+                        } | null | undefined;
+                    })[] | null | undefined;
+                } | {
+                    readonly type: "document";
+                    readonly source: {
+                        readonly type: "base64";
+                        readonly media_type: "application/pdf";
+                        readonly data: string;
+                    } | {
+                        readonly type: "text";
+                        readonly media_type: "text/plain";
+                        readonly data: string;
+                    } | {
+                        readonly type: "content";
+                        readonly content: string | readonly ({
+                            readonly type: "text";
+                            readonly text: string;
+                            readonly cache_control?: {
+                                readonly type: "ephemeral";
+                            } | null | undefined;
+                            readonly citations?: readonly ({
+                                readonly type: "char_location";
+                                readonly cited_text: string;
+                                readonly document_index: number;
+                                readonly document_title: string | null;
+                                readonly start_char_index: number;
+                                readonly end_char_index: number;
+                            } | {
+                                readonly type: "page_location";
+                                readonly cited_text: string;
+                                readonly document_index: number;
+                                readonly document_title: string | null;
+                                readonly start_page_number: number;
+                                readonly end_page_number: number;
+                            } | {
+                                readonly type: "content_block_location";
+                                readonly cited_text: string;
+                                readonly document_index: number;
+                                readonly document_title: string | null;
+                                readonly start_block_index: number;
+                                readonly end_block_index: number;
+                            })[] | null | undefined;
+                        } | {
+                            readonly type: "image";
+                            readonly source: {
+                                readonly type: "base64";
+                                readonly media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+                                readonly data: string;
+                            };
+                            readonly cache_control?: {
+                                readonly type: "ephemeral";
+                            } | null | undefined;
+                        })[];
+                    };
+                    readonly cache_control?: {
+                        readonly type: "ephemeral";
+                    } | null | undefined;
+                    readonly citations?: {
+                        readonly enabled?: boolean | null | undefined;
+                    } | null | undefined;
+                    readonly title?: string | null | undefined;
+                    readonly context?: string | null | undefined;
+                })[];
+                readonly role: "user" | "assistant";
+            }[];
+            readonly max_tokens: number;
+            readonly metadata?: {
+                readonly user_id?: string | null | undefined;
+            } | null | undefined;
+            readonly stop_sequences?: readonly string[] | null | undefined;
+            readonly stream?: boolean | null | undefined;
+            readonly system?: string | readonly {
+                readonly type: "text";
+                readonly text: string;
+                readonly cache_control?: {
+                    readonly type: "ephemeral";
+                } | null | undefined;
+                readonly citations?: readonly ({
+                    readonly type: "char_location";
+                    readonly cited_text: string;
+                    readonly document_index: number;
+                    readonly document_title: string | null;
+                    readonly start_char_index: number;
+                    readonly end_char_index: number;
+                } | {
+                    readonly type: "page_location";
+                    readonly cited_text: string;
+                    readonly document_index: number;
+                    readonly document_title: string | null;
+                    readonly start_page_number: number;
+                    readonly end_page_number: number;
+                } | {
+                    readonly type: "content_block_location";
+                    readonly cited_text: string;
+                    readonly document_index: number;
+                    readonly document_title: string | null;
+                    readonly start_block_index: number;
+                    readonly end_block_index: number;
+                })[] | null | undefined;
+            }[] | null | undefined;
+            readonly temperature?: number | null | undefined;
+            readonly tool_choice?: {
+                readonly type: "auto";
+                readonly disable_parallel_tool_use?: boolean | null | undefined;
+            } | {
+                readonly type: "any";
+                readonly disable_parallel_tool_use?: boolean | null | undefined;
+            } | {
+                readonly type: "tool";
+                readonly name: string;
+                readonly disable_parallel_tool_use?: boolean | null | undefined;
+            } | null | undefined;
+            readonly tools?: readonly {
+                readonly name: string;
+                readonly input_schema: {
+                    readonly type: "object";
+                    readonly properties?: {
+                        readonly [x: string]: unknown;
+                    } | null | undefined;
+                };
+                readonly cache_control?: {
+                    readonly type: "ephemeral";
+                } | null | undefined;
+                readonly description?: string | null | undefined;
+            }[] | null | undefined;
+            readonly top_k?: number | null | undefined;
+            readonly top_p?: number | null | undefined;
+        };
+    }[], never>>;
+}>, never, {
+    readonly requests: readonly {
+        readonly custom_id: string;
+        readonly params: CreateMessageParams;
+    }[];
+}, {}, {}>;
+export declare class CreateMessageBatchParams extends CreateMessageBatchParams_base {
+}
+declare const MessageBatchesRetrieveParams_base: S.Struct<{
+    "anthropic-version": S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    "x-api-key": S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+}>;
+export declare class MessageBatchesRetrieveParams extends MessageBatchesRetrieveParams_base {
+}
+declare const MessageBatchesDeleteParams_base: S.Struct<{
+    "anthropic-version": S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    "x-api-key": S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+}>;
+export declare class MessageBatchesDeleteParams extends MessageBatchesDeleteParams_base {
+}
+declare const DeleteMessageBatchResponseType_base: S.Literal<["message_batch_deleted"]>;
+export declare class DeleteMessageBatchResponseType extends DeleteMessageBatchResponseType_base {
+}
+declare const DeleteMessageBatchResponse_base: S.Class<DeleteMessageBatchResponse, {
+    id: typeof S.String;
+    type: S.PropertySignature<":", "message_batch_deleted", never, ":", "message_batch_deleted", true, never>;
+}, S.Struct.Encoded<{
+    id: typeof S.String;
+    type: S.PropertySignature<":", "message_batch_deleted", never, ":", "message_batch_deleted", true, never>;
+}>, never, {
+    readonly type?: "message_batch_deleted" | undefined;
+} & {
+    readonly id: string;
+}, {}, {}>;
+export declare class DeleteMessageBatchResponse extends DeleteMessageBatchResponse_base {
+}
+declare const MessageBatchesCancelParams_base: S.Struct<{
+    "anthropic-version": S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+}>;
+export declare class MessageBatchesCancelParams extends MessageBatchesCancelParams_base {
+}
+declare const MessageBatchesResultsParams_base: S.Struct<{
+    "anthropic-version": S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    "x-api-key": S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+}>;
+export declare class MessageBatchesResultsParams extends MessageBatchesResultsParams_base {
+}
+declare const MessagesCountTokensPostParams_base: S.Struct<{
+    "anthropic-version": S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+}>;
+export declare class MessagesCountTokensPostParams extends MessagesCountTokensPostParams_base {
+}
+declare const CountMessageTokensParams_base: S.Class<CountMessageTokensParams, {
+    tool_choice: S.optionalWith<typeof ToolChoice, {
+        nullable: true;
+    }>;
+    tools: S.optionalWith<S.Array$<typeof Tool>, {
+        nullable: true;
+    }>;
+    messages: S.Array$<typeof InputMessage>;
+    system: S.optionalWith<S.Union<[typeof S.String, S.Array$<typeof RequestTextBlock>]>, {
+        nullable: true;
+    }>;
+    model: typeof Model;
+}, S.Struct.Encoded<{
+    tool_choice: S.optionalWith<typeof ToolChoice, {
+        nullable: true;
+    }>;
+    tools: S.optionalWith<S.Array$<typeof Tool>, {
+        nullable: true;
+    }>;
+    messages: S.Array$<typeof InputMessage>;
+    system: S.optionalWith<S.Union<[typeof S.String, S.Array$<typeof RequestTextBlock>]>, {
+        nullable: true;
+    }>;
+    model: typeof Model;
+}>, never, {
+    readonly model: string;
+} & {
+    readonly messages: readonly {
+        readonly content: string | readonly ({
+            readonly type: "text";
+            readonly text: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+            } | null | undefined;
+            readonly citations?: readonly ({
+                readonly type: "char_location";
+                readonly cited_text: string;
+                readonly document_index: number;
+                readonly document_title: string | null;
+                readonly start_char_index: number;
+                readonly end_char_index: number;
+            } | {
+                readonly type: "page_location";
+                readonly cited_text: string;
+                readonly document_index: number;
+                readonly document_title: string | null;
+                readonly start_page_number: number;
+                readonly end_page_number: number;
+            } | {
+                readonly type: "content_block_location";
+                readonly cited_text: string;
+                readonly document_index: number;
+                readonly document_title: string | null;
+                readonly start_block_index: number;
+                readonly end_block_index: number;
+            })[] | null | undefined;
+        } | {
+            readonly type: "image";
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+            } | null | undefined;
+            readonly source: {
+                readonly type: "base64";
+                readonly media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+                readonly data: string;
+            };
+        } | {
+            readonly type: "tool_use";
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+            } | null | undefined;
+            readonly id: string;
+            readonly name: string;
+            readonly input: {
+                readonly [x: string]: unknown;
+            };
+        } | {
+            readonly type: "tool_result";
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+            } | null | undefined;
+            readonly tool_use_id: string;
+            readonly is_error?: boolean | undefined;
+            readonly content?: string | readonly ({
+                readonly type: "text";
+                readonly text: string;
+                readonly cache_control?: {
+                    readonly type: "ephemeral";
+                } | null | undefined;
+                readonly citations?: readonly ({
+                    readonly type: "char_location";
+                    readonly cited_text: string;
+                    readonly document_index: number;
+                    readonly document_title: string | null;
+                    readonly start_char_index: number;
+                    readonly end_char_index: number;
+                } | {
+                    readonly type: "page_location";
+                    readonly cited_text: string;
+                    readonly document_index: number;
+                    readonly document_title: string | null;
+                    readonly start_page_number: number;
+                    readonly end_page_number: number;
+                } | {
+                    readonly type: "content_block_location";
+                    readonly cited_text: string;
+                    readonly document_index: number;
+                    readonly document_title: string | null;
+                    readonly start_block_index: number;
+                    readonly end_block_index: number;
+                })[] | null | undefined;
+            } | {
+                readonly type: "image";
+                readonly cache_control?: {
+                    readonly type: "ephemeral";
+                } | null | undefined;
+                readonly source: {
+                    readonly type: "base64";
+                    readonly media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+                    readonly data: string;
+                };
+            })[] | undefined;
+        } | {
+            readonly type: "document";
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+            } | null | undefined;
+            readonly citations?: {
+                readonly enabled?: boolean | undefined;
+            } | undefined;
+            readonly source: {
+                readonly type: "base64";
+                readonly media_type: "application/pdf";
+                readonly data: string;
+            } | {
+                readonly type: "text";
+                readonly media_type: "text/plain";
+                readonly data: string;
+            } | {
+                readonly type: "content";
+                readonly content: string | readonly ({
+                    readonly type: "text";
+                    readonly text: string;
+                    readonly cache_control?: {
+                        readonly type: "ephemeral";
+                    } | null | undefined;
+                    readonly citations?: readonly ({
+                        readonly type: "char_location";
+                        readonly cited_text: string;
+                        readonly document_index: number;
+                        readonly document_title: string | null;
+                        readonly start_char_index: number;
+                        readonly end_char_index: number;
+                    } | {
+                        readonly type: "page_location";
+                        readonly cited_text: string;
+                        readonly document_index: number;
+                        readonly document_title: string | null;
+                        readonly start_page_number: number;
+                        readonly end_page_number: number;
+                    } | {
+                        readonly type: "content_block_location";
+                        readonly cited_text: string;
+                        readonly document_index: number;
+                        readonly document_title: string | null;
+                        readonly start_block_index: number;
+                        readonly end_block_index: number;
+                    })[] | null | undefined;
+                } | {
+                    readonly type: "image";
+                    readonly cache_control?: {
+                        readonly type: "ephemeral";
+                    } | null | undefined;
+                    readonly source: {
+                        readonly type: "base64";
+                        readonly media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+                        readonly data: string;
+                    };
+                })[];
+            };
+            readonly title?: string | null | undefined;
+            readonly context?: string | null | undefined;
+        })[];
+        readonly role: "user" | "assistant";
+    }[];
+} & {
+    readonly system?: string | readonly {
+        readonly type: "text";
+        readonly text: string;
+        readonly cache_control?: {
+            readonly type: "ephemeral";
+        } | null | undefined;
+        readonly citations?: readonly ({
+            readonly type: "char_location";
+            readonly cited_text: string;
+            readonly document_index: number;
+            readonly document_title: string | null;
+            readonly start_char_index: number;
+            readonly end_char_index: number;
+        } | {
+            readonly type: "page_location";
+            readonly cited_text: string;
+            readonly document_index: number;
+            readonly document_title: string | null;
+            readonly start_page_number: number;
+            readonly end_page_number: number;
+        } | {
+            readonly type: "content_block_location";
+            readonly cited_text: string;
+            readonly document_index: number;
+            readonly document_title: string | null;
+            readonly start_block_index: number;
+            readonly end_block_index: number;
+        })[] | null | undefined;
+    }[] | undefined;
+} & {
+    readonly tool_choice?: {
+        readonly type: "auto";
+        readonly disable_parallel_tool_use?: boolean | undefined;
+    } | {
+        readonly type: "any";
+        readonly disable_parallel_tool_use?: boolean | undefined;
+    } | {
+        readonly type: "tool";
+        readonly name: string;
+        readonly disable_parallel_tool_use?: boolean | undefined;
+    } | undefined;
+} & {
+    readonly tools?: readonly {
+        readonly cache_control?: {
+            readonly type: "ephemeral";
+        } | null | undefined;
+        readonly name: string;
+        readonly description?: string | undefined;
+        readonly input_schema: {
+            readonly type: "object";
+            readonly properties?: {
+                readonly [x: string]: unknown;
+            } | null | undefined;
+        };
+    }[] | undefined;
+}, {}, {}>;
+export declare class CountMessageTokensParams extends CountMessageTokensParams_base {
+}
+declare const CountMessageTokensResponse_base: S.Class<CountMessageTokensResponse, {
+    input_tokens: typeof S.Int;
+}, S.Struct.Encoded<{
+    input_tokens: typeof S.Int;
+}>, never, {
+    readonly input_tokens: number;
+}, {}, {}>;
+export declare class CountMessageTokensResponse extends CountMessageTokensResponse_base {
+}
+declare const BetaMessagesPostParams_base: S.Struct<{
+    "anthropic-beta": S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    "anthropic-version": S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+}>;
+export declare class BetaMessagesPostParams extends BetaMessagesPostParams_base {
+}
+declare const BetaInputMessageRole_base: S.Literal<["user", "assistant"]>;
+export declare class BetaInputMessageRole extends BetaInputMessageRole_base {
+}
+declare const BetaCacheControlEphemeralType_base: S.Literal<["ephemeral"]>;
+export declare class BetaCacheControlEphemeralType extends BetaCacheControlEphemeralType_base {
+}
+declare const BetaCacheControlEphemeral_base: S.Struct<{
+    type: typeof BetaCacheControlEphemeralType;
+}>;
+export declare class BetaCacheControlEphemeral extends BetaCacheControlEphemeral_base {
+}
+declare const BetaRequestCharLocationCitationType_base: S.Literal<["char_location"]>;
+export declare class BetaRequestCharLocationCitationType extends BetaRequestCharLocationCitationType_base {
+}
+declare const BetaRequestCharLocationCitation_base: S.Struct<{
+    type: typeof BetaRequestCharLocationCitationType;
+    cited_text: typeof S.String;
+    document_index: S.filter<S.Schema<number, number, never>>;
+    document_title: S.Union<[S.filter<S.Schema<string, string, never>>, typeof S.Null]>;
+    start_char_index: S.filter<S.Schema<number, number, never>>;
+    end_char_index: typeof S.Int;
+}>;
+export declare class BetaRequestCharLocationCitation extends BetaRequestCharLocationCitation_base {
+}
+declare const BetaRequestPageLocationCitationType_base: S.Literal<["page_location"]>;
+export declare class BetaRequestPageLocationCitationType extends BetaRequestPageLocationCitationType_base {
+}
+declare const BetaRequestPageLocationCitation_base: S.Struct<{
+    type: typeof BetaRequestPageLocationCitationType;
+    cited_text: typeof S.String;
+    document_index: S.filter<S.Schema<number, number, never>>;
+    document_title: S.Union<[S.filter<S.Schema<string, string, never>>, typeof S.Null]>;
+    start_page_number: S.filter<S.Schema<number, number, never>>;
+    end_page_number: typeof S.Int;
+}>;
+export declare class BetaRequestPageLocationCitation extends BetaRequestPageLocationCitation_base {
+}
+declare const BetaRequestContentBlockLocationCitationType_base: S.Literal<["content_block_location"]>;
+export declare class BetaRequestContentBlockLocationCitationType extends BetaRequestContentBlockLocationCitationType_base {
+}
+declare const BetaRequestContentBlockLocationCitation_base: S.Struct<{
+    type: typeof BetaRequestContentBlockLocationCitationType;
+    cited_text: typeof S.String;
+    document_index: S.filter<S.Schema<number, number, never>>;
+    document_title: S.Union<[S.filter<S.Schema<string, string, never>>, typeof S.Null]>;
+    start_block_index: S.filter<S.Schema<number, number, never>>;
+    end_block_index: typeof S.Int;
+}>;
+export declare class BetaRequestContentBlockLocationCitation extends BetaRequestContentBlockLocationCitation_base {
+}
+declare const BetaRequestTextBlockType_base: S.Literal<["text"]>;
+export declare class BetaRequestTextBlockType extends BetaRequestTextBlockType_base {
+}
+declare const BetaRequestTextBlock_base: S.Struct<{
+    cache_control: S.optionalWith<S.Union<[typeof BetaCacheControlEphemeral, typeof S.Null]>, {
+        nullable: true;
+    }>;
+    citations: S.optionalWith<S.Union<[S.Array$<S.Union<[typeof BetaRequestCharLocationCitation, typeof BetaRequestPageLocationCitation, typeof BetaRequestContentBlockLocationCitation]>>, typeof S.Null]>, {
+        nullable: true;
+    }>;
+    text: S.filter<S.Schema<string, string, never>>;
+    type: typeof BetaRequestTextBlockType;
+}>;
+export declare class BetaRequestTextBlock extends BetaRequestTextBlock_base {
+}
+declare const BetaRequestImageBlockType_base: S.Literal<["image"]>;
+export declare class BetaRequestImageBlockType extends BetaRequestImageBlockType_base {
+}
+declare const BetaBase64ImageSourceType_base: S.Literal<["base64"]>;
+export declare class BetaBase64ImageSourceType extends BetaBase64ImageSourceType_base {
+}
+declare const BetaBase64ImageSourceMediaType_base: S.Literal<["image/jpeg", "image/png", "image/gif", "image/webp"]>;
+export declare class BetaBase64ImageSourceMediaType extends BetaBase64ImageSourceMediaType_base {
+}
+declare const BetaBase64ImageSource_base: S.Struct<{
+    type: typeof BetaBase64ImageSourceType;
+    media_type: typeof BetaBase64ImageSourceMediaType;
+    data: typeof S.String;
+}>;
+export declare class BetaBase64ImageSource extends BetaBase64ImageSource_base {
+}
+declare const BetaRequestImageBlock_base: S.Struct<{
+    cache_control: S.optionalWith<S.Union<[typeof BetaCacheControlEphemeral, typeof S.Null]>, {
+        nullable: true;
+    }>;
+    type: typeof BetaRequestImageBlockType;
+    source: typeof BetaBase64ImageSource;
+}>;
+export declare class BetaRequestImageBlock extends BetaRequestImageBlock_base {
+}
+declare const BetaRequestToolUseBlockType_base: S.Literal<["tool_use"]>;
+export declare class BetaRequestToolUseBlockType extends BetaRequestToolUseBlockType_base {
+}
+declare const BetaRequestToolUseBlock_base: S.Struct<{
+    cache_control: S.optionalWith<S.Union<[typeof BetaCacheControlEphemeral, typeof S.Null]>, {
+        nullable: true;
+    }>;
+    type: typeof BetaRequestToolUseBlockType;
+    id: S.filter<S.Schema<string, string, never>>;
+    name: S.filter<S.Schema<string, string, never>>;
+    input: S.Record$<typeof S.String, typeof S.Unknown>;
+}>;
+export declare class BetaRequestToolUseBlock extends BetaRequestToolUseBlock_base {
+}
+declare const BetaRequestToolResultBlockType_base: S.Literal<["tool_result"]>;
+export declare class BetaRequestToolResultBlockType extends BetaRequestToolResultBlockType_base {
+}
+declare const BetaRequestToolResultBlock_base: S.Struct<{
+    cache_control: S.optionalWith<S.Union<[typeof BetaCacheControlEphemeral, typeof S.Null]>, {
+        nullable: true;
+    }>;
+    type: typeof BetaRequestToolResultBlockType;
+    tool_use_id: S.filter<S.Schema<string, string, never>>;
+    is_error: S.optionalWith<typeof S.Boolean, {
+        nullable: true;
+    }>;
+    content: S.optionalWith<S.Union<[typeof S.String, S.Array$<S.Union<[typeof BetaRequestTextBlock, typeof BetaRequestImageBlock]>>]>, {
+        nullable: true;
+    }>;
+}>;
+export declare class BetaRequestToolResultBlock extends BetaRequestToolResultBlock_base {
+}
+declare const BetaRequestDocumentBlockType_base: S.Literal<["document"]>;
+export declare class BetaRequestDocumentBlockType extends BetaRequestDocumentBlockType_base {
+}
+declare const BetaBase64PDFSourceType_base: S.Literal<["base64"]>;
+export declare class BetaBase64PDFSourceType extends BetaBase64PDFSourceType_base {
+}
+declare const BetaBase64PDFSourceMediaType_base: S.Literal<["application/pdf"]>;
+export declare class BetaBase64PDFSourceMediaType extends BetaBase64PDFSourceMediaType_base {
+}
+declare const BetaBase64PDFSource_base: S.Struct<{
+    type: typeof BetaBase64PDFSourceType;
+    media_type: typeof BetaBase64PDFSourceMediaType;
+    data: typeof S.String;
+}>;
+export declare class BetaBase64PDFSource extends BetaBase64PDFSource_base {
+}
+declare const BetaPlainTextSourceType_base: S.Literal<["text"]>;
+export declare class BetaPlainTextSourceType extends BetaPlainTextSourceType_base {
+}
+declare const BetaPlainTextSourceMediaType_base: S.Literal<["text/plain"]>;
+export declare class BetaPlainTextSourceMediaType extends BetaPlainTextSourceMediaType_base {
+}
+declare const BetaPlainTextSource_base: S.Struct<{
+    type: typeof BetaPlainTextSourceType;
+    media_type: typeof BetaPlainTextSourceMediaType;
+    data: typeof S.String;
+}>;
+export declare class BetaPlainTextSource extends BetaPlainTextSource_base {
+}
+declare const BetaContentBlockSourceType_base: S.Literal<["content"]>;
+export declare class BetaContentBlockSourceType extends BetaContentBlockSourceType_base {
+}
+declare const BetaContentBlockSource_base: S.Struct<{
+    type: typeof BetaContentBlockSourceType;
+    content: S.Union<[typeof S.String, S.Array$<S.Union<[typeof BetaRequestTextBlock, typeof BetaRequestImageBlock]>>]>;
+}>;
+export declare class BetaContentBlockSource extends BetaContentBlockSource_base {
+}
+declare const BetaRequestCitationsConfig_base: S.Struct<{
+    enabled: S.optionalWith<typeof S.Boolean, {
+        nullable: true;
+    }>;
+}>;
+export declare class BetaRequestCitationsConfig extends BetaRequestCitationsConfig_base {
+}
+declare const BetaRequestDocumentBlock_base: S.Struct<{
+    cache_control: S.optionalWith<S.Union<[typeof BetaCacheControlEphemeral, typeof S.Null]>, {
+        nullable: true;
+    }>;
+    type: typeof BetaRequestDocumentBlockType;
+    source: S.Union<[typeof BetaBase64PDFSource, typeof BetaPlainTextSource, typeof BetaContentBlockSource]>;
+    title: S.optionalWith<S.Union<[S.filter<S.Schema<string, string, never>>, typeof S.Null]>, {
+        nullable: true;
+    }>;
+    context: S.optionalWith<S.Union<[S.filter<S.Schema<string, string, never>>, typeof S.Null]>, {
+        nullable: true;
+    }>;
+    citations: S.optionalWith<typeof BetaRequestCitationsConfig, {
+        nullable: true;
+    }>;
+}>;
+export declare class BetaRequestDocumentBlock extends BetaRequestDocumentBlock_base {
+}
+declare const BetaInputContentBlock_base: S.Union<[typeof BetaRequestTextBlock, typeof BetaRequestImageBlock, typeof BetaRequestToolUseBlock, typeof BetaRequestToolResultBlock, typeof BetaRequestDocumentBlock]>;
+export declare class BetaInputContentBlock extends BetaInputContentBlock_base {
+}
+declare const BetaInputMessage_base: S.Struct<{
+    role: typeof BetaInputMessageRole;
+    content: S.Union<[typeof S.String, S.Array$<typeof BetaInputContentBlock>]>;
+}>;
+export declare class BetaInputMessage extends BetaInputMessage_base {
+}
+declare const BetaMetadata_base: S.Struct<{
+    user_id: S.optionalWith<S.Union<[S.filter<S.Schema<string, string, never>>, typeof S.Null]>, {
+        nullable: true;
+    }>;
+}>;
+export declare class BetaMetadata extends BetaMetadata_base {
+}
+declare const BetaToolChoiceAutoType_base: S.Literal<["auto"]>;
+export declare class BetaToolChoiceAutoType extends BetaToolChoiceAutoType_base {
+}
+declare const BetaToolChoiceAuto_base: S.Struct<{
+    type: typeof BetaToolChoiceAutoType;
+    disable_parallel_tool_use: S.optionalWith<typeof S.Boolean, {
+        nullable: true;
+    }>;
+}>;
+export declare class BetaToolChoiceAuto extends BetaToolChoiceAuto_base {
+}
+declare const BetaToolChoiceAnyType_base: S.Literal<["any"]>;
+export declare class BetaToolChoiceAnyType extends BetaToolChoiceAnyType_base {
+}
+declare const BetaToolChoiceAny_base: S.Struct<{
+    type: typeof BetaToolChoiceAnyType;
+    disable_parallel_tool_use: S.optionalWith<typeof S.Boolean, {
+        nullable: true;
+    }>;
+}>;
+export declare class BetaToolChoiceAny extends BetaToolChoiceAny_base {
+}
+declare const BetaToolChoiceToolType_base: S.Literal<["tool"]>;
+export declare class BetaToolChoiceToolType extends BetaToolChoiceToolType_base {
+}
+declare const BetaToolChoiceTool_base: S.Struct<{
+    type: typeof BetaToolChoiceToolType;
+    name: typeof S.String;
+    disable_parallel_tool_use: S.optionalWith<typeof S.Boolean, {
+        nullable: true;
+    }>;
+}>;
+export declare class BetaToolChoiceTool extends BetaToolChoiceTool_base {
+}
+declare const BetaToolChoice_base: S.Union<[typeof BetaToolChoiceAuto, typeof BetaToolChoiceAny, typeof BetaToolChoiceTool]>;
+export declare class BetaToolChoice extends BetaToolChoice_base {
+}
+declare const BetaToolTypeEnum_base: S.Literal<["custom"]>;
+export declare class BetaToolTypeEnum extends BetaToolTypeEnum_base {
+}
+declare const BetaInputSchemaType_base: S.Literal<["object"]>;
+export declare class BetaInputSchemaType extends BetaInputSchemaType_base {
+}
+declare const BetaInputSchema_base: S.Struct<{
+    type: typeof BetaInputSchemaType;
+    properties: S.optionalWith<S.Union<[S.Record$<typeof S.String, typeof S.Unknown>, typeof S.Null]>, {
+        nullable: true;
+    }>;
+}>;
+export declare class BetaInputSchema extends BetaInputSchema_base {
+}
+declare const BetaTool_base: S.Struct<{
+    type: S.optionalWith<S.Union<[typeof S.Null, typeof BetaToolTypeEnum]>, {
+        nullable: true;
+    }>;
+    description: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    name: S.filter<S.Schema<string, string, never>>;
+    input_schema: typeof BetaInputSchema;
+    cache_control: S.optionalWith<S.Union<[typeof BetaCacheControlEphemeral, typeof S.Null]>, {
+        nullable: true;
+    }>;
+}>;
+export declare class BetaTool extends BetaTool_base {
+}
+declare const BetaComputerUseTool20241022Type_base: S.Literal<["computer_20241022"]>;
+export declare class BetaComputerUseTool20241022Type extends BetaComputerUseTool20241022Type_base {
+}
+declare const BetaComputerUseTool20241022Name_base: S.Literal<["computer"]>;
+export declare class BetaComputerUseTool20241022Name extends BetaComputerUseTool20241022Name_base {
+}
+declare const BetaComputerUseTool20241022_base: S.Struct<{
+    cache_control: S.optionalWith<S.Union<[typeof BetaCacheControlEphemeral, typeof S.Null]>, {
+        nullable: true;
+    }>;
+    type: typeof BetaComputerUseTool20241022Type;
+    name: typeof BetaComputerUseTool20241022Name;
+    display_height_px: S.filter<S.Schema<number, number, never>>;
+    display_width_px: S.filter<S.Schema<number, number, never>>;
+    display_number: S.optionalWith<S.Union<[S.filter<S.Schema<number, number, never>>, typeof S.Null]>, {
+        nullable: true;
+    }>;
+}>;
+export declare class BetaComputerUseTool20241022 extends BetaComputerUseTool20241022_base {
+}
+declare const BetaBashTool20241022Type_base: S.Literal<["bash_20241022"]>;
+export declare class BetaBashTool20241022Type extends BetaBashTool20241022Type_base {
+}
+declare const BetaBashTool20241022Name_base: S.Literal<["bash"]>;
+export declare class BetaBashTool20241022Name extends BetaBashTool20241022Name_base {
+}
+declare const BetaBashTool20241022_base: S.Struct<{
+    cache_control: S.optionalWith<S.Union<[typeof BetaCacheControlEphemeral, typeof S.Null]>, {
+        nullable: true;
+    }>;
+    type: typeof BetaBashTool20241022Type;
+    name: typeof BetaBashTool20241022Name;
+}>;
+export declare class BetaBashTool20241022 extends BetaBashTool20241022_base {
+}
+declare const BetaTextEditor20241022Type_base: S.Literal<["text_editor_20241022"]>;
+export declare class BetaTextEditor20241022Type extends BetaTextEditor20241022Type_base {
+}
+declare const BetaTextEditor20241022Name_base: S.Literal<["str_replace_editor"]>;
+export declare class BetaTextEditor20241022Name extends BetaTextEditor20241022Name_base {
+}
+declare const BetaTextEditor20241022_base: S.Struct<{
+    cache_control: S.optionalWith<S.Union<[typeof BetaCacheControlEphemeral, typeof S.Null]>, {
+        nullable: true;
+    }>;
+    type: typeof BetaTextEditor20241022Type;
+    name: typeof BetaTextEditor20241022Name;
+}>;
+export declare class BetaTextEditor20241022 extends BetaTextEditor20241022_base {
+}
+declare const BetaCreateMessageParams_base: S.Class<BetaCreateMessageParams, {
+    model: typeof Model;
+    messages: S.Array$<typeof BetaInputMessage>;
+    max_tokens: S.filter<S.Schema<number, number, never>>;
+    metadata: S.optionalWith<typeof BetaMetadata, {
+        nullable: true;
+    }>;
+    stop_sequences: S.optionalWith<S.Array$<typeof S.String>, {
+        nullable: true;
+    }>;
+    stream: S.optionalWith<typeof S.Boolean, {
+        nullable: true;
+    }>;
+    system: S.optionalWith<S.Union<[typeof S.String, S.Array$<typeof BetaRequestTextBlock>]>, {
+        nullable: true;
+    }>;
+    temperature: S.optionalWith<S.filter<S.Schema<number, number, never>>, {
+        nullable: true;
+    }>;
+    tool_choice: S.optionalWith<typeof BetaToolChoice, {
+        nullable: true;
+    }>;
+    tools: S.optionalWith<S.Array$<S.Union<[typeof BetaTool, typeof BetaComputerUseTool20241022, typeof BetaBashTool20241022, typeof BetaTextEditor20241022]>>, {
+        nullable: true;
+    }>;
+    top_k: S.optionalWith<S.filter<S.Schema<number, number, never>>, {
+        nullable: true;
+    }>;
+    top_p: S.optionalWith<S.filter<S.Schema<number, number, never>>, {
+        nullable: true;
+    }>;
+}, S.Struct.Encoded<{
+    model: typeof Model;
+    messages: S.Array$<typeof BetaInputMessage>;
+    max_tokens: S.filter<S.Schema<number, number, never>>;
+    metadata: S.optionalWith<typeof BetaMetadata, {
+        nullable: true;
+    }>;
+    stop_sequences: S.optionalWith<S.Array$<typeof S.String>, {
+        nullable: true;
+    }>;
+    stream: S.optionalWith<typeof S.Boolean, {
+        nullable: true;
+    }>;
+    system: S.optionalWith<S.Union<[typeof S.String, S.Array$<typeof BetaRequestTextBlock>]>, {
+        nullable: true;
+    }>;
+    temperature: S.optionalWith<S.filter<S.Schema<number, number, never>>, {
+        nullable: true;
+    }>;
+    tool_choice: S.optionalWith<typeof BetaToolChoice, {
+        nullable: true;
+    }>;
+    tools: S.optionalWith<S.Array$<S.Union<[typeof BetaTool, typeof BetaComputerUseTool20241022, typeof BetaBashTool20241022, typeof BetaTextEditor20241022]>>, {
+        nullable: true;
+    }>;
+    top_k: S.optionalWith<S.filter<S.Schema<number, number, never>>, {
+        nullable: true;
+    }>;
+    top_p: S.optionalWith<S.filter<S.Schema<number, number, never>>, {
+        nullable: true;
+    }>;
+}>, never, {
+    readonly model: string;
+} & {
+    readonly messages: readonly {
+        readonly content: string | readonly ({
+            readonly type: "text";
+            readonly text: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+            } | null | undefined;
+            readonly citations?: readonly ({
+                readonly type: "char_location";
+                readonly cited_text: string;
+                readonly document_index: number;
+                readonly document_title: string | null;
+                readonly start_char_index: number;
+                readonly end_char_index: number;
+            } | {
+                readonly type: "page_location";
+                readonly cited_text: string;
+                readonly document_index: number;
+                readonly document_title: string | null;
+                readonly start_page_number: number;
+                readonly end_page_number: number;
+            } | {
+                readonly type: "content_block_location";
+                readonly cited_text: string;
+                readonly document_index: number;
+                readonly document_title: string | null;
+                readonly start_block_index: number;
+                readonly end_block_index: number;
+            })[] | null | undefined;
+        } | {
+            readonly type: "image";
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+            } | null | undefined;
+            readonly source: {
+                readonly type: "base64";
+                readonly media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+                readonly data: string;
+            };
+        } | {
+            readonly type: "tool_use";
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+            } | null | undefined;
+            readonly id: string;
+            readonly name: string;
+            readonly input: {
+                readonly [x: string]: unknown;
+            };
+        } | {
+            readonly type: "tool_result";
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+            } | null | undefined;
+            readonly tool_use_id: string;
+            readonly is_error?: boolean | undefined;
+            readonly content?: string | readonly ({
+                readonly type: "text";
+                readonly text: string;
+                readonly cache_control?: {
+                    readonly type: "ephemeral";
+                } | null | undefined;
+                readonly citations?: readonly ({
+                    readonly type: "char_location";
+                    readonly cited_text: string;
+                    readonly document_index: number;
+                    readonly document_title: string | null;
+                    readonly start_char_index: number;
+                    readonly end_char_index: number;
+                } | {
+                    readonly type: "page_location";
+                    readonly cited_text: string;
+                    readonly document_index: number;
+                    readonly document_title: string | null;
+                    readonly start_page_number: number;
+                    readonly end_page_number: number;
+                } | {
+                    readonly type: "content_block_location";
+                    readonly cited_text: string;
+                    readonly document_index: number;
+                    readonly document_title: string | null;
+                    readonly start_block_index: number;
+                    readonly end_block_index: number;
+                })[] | null | undefined;
+            } | {
+                readonly type: "image";
+                readonly cache_control?: {
+                    readonly type: "ephemeral";
+                } | null | undefined;
+                readonly source: {
+                    readonly type: "base64";
+                    readonly media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+                    readonly data: string;
+                };
+            })[] | undefined;
+        } | {
+            readonly type: "document";
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+            } | null | undefined;
+            readonly citations?: {
+                readonly enabled?: boolean | undefined;
+            } | undefined;
+            readonly source: {
+                readonly type: "base64";
+                readonly media_type: "application/pdf";
+                readonly data: string;
+            } | {
+                readonly type: "text";
+                readonly media_type: "text/plain";
+                readonly data: string;
+            } | {
+                readonly type: "content";
+                readonly content: string | readonly ({
+                    readonly type: "text";
+                    readonly text: string;
+                    readonly cache_control?: {
+                        readonly type: "ephemeral";
+                    } | null | undefined;
+                    readonly citations?: readonly ({
+                        readonly type: "char_location";
+                        readonly cited_text: string;
+                        readonly document_index: number;
+                        readonly document_title: string | null;
+                        readonly start_char_index: number;
+                        readonly end_char_index: number;
+                    } | {
+                        readonly type: "page_location";
+                        readonly cited_text: string;
+                        readonly document_index: number;
+                        readonly document_title: string | null;
+                        readonly start_page_number: number;
+                        readonly end_page_number: number;
+                    } | {
+                        readonly type: "content_block_location";
+                        readonly cited_text: string;
+                        readonly document_index: number;
+                        readonly document_title: string | null;
+                        readonly start_block_index: number;
+                        readonly end_block_index: number;
+                    })[] | null | undefined;
+                } | {
+                    readonly type: "image";
+                    readonly cache_control?: {
+                        readonly type: "ephemeral";
+                    } | null | undefined;
+                    readonly source: {
+                        readonly type: "base64";
+                        readonly media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+                        readonly data: string;
+                    };
+                })[];
+            };
+            readonly title?: string | null | undefined;
+            readonly context?: string | null | undefined;
+        })[];
+        readonly role: "user" | "assistant";
+    }[];
+} & {
+    readonly max_tokens: number;
+} & {
+    readonly metadata?: {
+        readonly user_id?: string | null | undefined;
+    } | undefined;
+} & {
+    readonly stop_sequences?: readonly string[] | undefined;
+} & {
+    readonly stream?: boolean | undefined;
+} & {
+    readonly system?: string | readonly {
+        readonly type: "text";
+        readonly text: string;
+        readonly cache_control?: {
+            readonly type: "ephemeral";
+        } | null | undefined;
+        readonly citations?: readonly ({
+            readonly type: "char_location";
+            readonly cited_text: string;
+            readonly document_index: number;
+            readonly document_title: string | null;
+            readonly start_char_index: number;
+            readonly end_char_index: number;
+        } | {
+            readonly type: "page_location";
+            readonly cited_text: string;
+            readonly document_index: number;
+            readonly document_title: string | null;
+            readonly start_page_number: number;
+            readonly end_page_number: number;
+        } | {
+            readonly type: "content_block_location";
+            readonly cited_text: string;
+            readonly document_index: number;
+            readonly document_title: string | null;
+            readonly start_block_index: number;
+            readonly end_block_index: number;
+        })[] | null | undefined;
+    }[] | undefined;
+} & {
+    readonly temperature?: number | undefined;
+} & {
+    readonly tool_choice?: {
+        readonly type: "auto";
+        readonly disable_parallel_tool_use?: boolean | undefined;
+    } | {
+        readonly type: "any";
+        readonly disable_parallel_tool_use?: boolean | undefined;
+    } | {
+        readonly type: "tool";
+        readonly name: string;
+        readonly disable_parallel_tool_use?: boolean | undefined;
+    } | undefined;
+} & {
+    readonly tools?: readonly ({
+        readonly type?: "custom" | null | undefined;
+        readonly cache_control?: {
+            readonly type: "ephemeral";
+        } | null | undefined;
+        readonly name: string;
+        readonly description?: string | undefined;
+        readonly input_schema: {
+            readonly type: "object";
+            readonly properties?: {
+                readonly [x: string]: unknown;
+            } | null | undefined;
+        };
+    } | {
+        readonly type: "computer_20241022";
+        readonly cache_control?: {
+            readonly type: "ephemeral";
+        } | null | undefined;
+        readonly name: "computer";
+        readonly display_height_px: number;
+        readonly display_width_px: number;
+        readonly display_number?: number | null | undefined;
+    } | {
+        readonly type: "bash_20241022";
+        readonly cache_control?: {
+            readonly type: "ephemeral";
+        } | null | undefined;
+        readonly name: "bash";
+    } | {
+        readonly type: "text_editor_20241022";
+        readonly cache_control?: {
+            readonly type: "ephemeral";
+        } | null | undefined;
+        readonly name: "str_replace_editor";
+    })[] | undefined;
+} & {
+    readonly top_k?: number | undefined;
+} & {
+    readonly top_p?: number | undefined;
+}, {}, {}>;
+export declare class BetaCreateMessageParams extends BetaCreateMessageParams_base {
+}
+declare const BetaMessageType_base: S.Literal<["message"]>;
+export declare class BetaMessageType extends BetaMessageType_base {
+}
+declare const BetaMessageRole_base: S.Literal<["assistant"]>;
+export declare class BetaMessageRole extends BetaMessageRole_base {
+}
+declare const BetaResponseTextBlockType_base: S.Literal<["text"]>;
+export declare class BetaResponseTextBlockType extends BetaResponseTextBlockType_base {
+}
+declare const BetaResponseCharLocationCitationType_base: S.Literal<["char_location"]>;
+export declare class BetaResponseCharLocationCitationType extends BetaResponseCharLocationCitationType_base {
+}
+declare const BetaResponseCharLocationCitation_base: S.Struct<{
+    type: S.PropertySignature<":", "char_location", never, ":", "char_location", true, never>;
+    cited_text: typeof S.String;
+    document_index: S.filter<S.Schema<number, number, never>>;
+    document_title: S.Union<[typeof S.String, typeof S.Null]>;
+    start_char_index: S.filter<S.Schema<number, number, never>>;
+    end_char_index: typeof S.Int;
+}>;
+export declare class BetaResponseCharLocationCitation extends BetaResponseCharLocationCitation_base {
+}
+declare const BetaResponsePageLocationCitationType_base: S.Literal<["page_location"]>;
+export declare class BetaResponsePageLocationCitationType extends BetaResponsePageLocationCitationType_base {
+}
+declare const BetaResponsePageLocationCitation_base: S.Struct<{
+    type: S.PropertySignature<":", "page_location", never, ":", "page_location", true, never>;
+    cited_text: typeof S.String;
+    document_index: S.filter<S.Schema<number, number, never>>;
+    document_title: S.Union<[typeof S.String, typeof S.Null]>;
+    start_page_number: S.filter<S.Schema<number, number, never>>;
+    end_page_number: typeof S.Int;
+}>;
+export declare class BetaResponsePageLocationCitation extends BetaResponsePageLocationCitation_base {
+}
+declare const BetaResponseContentBlockLocationCitationType_base: S.Literal<["content_block_location"]>;
+export declare class BetaResponseContentBlockLocationCitationType extends BetaResponseContentBlockLocationCitationType_base {
+}
+declare const BetaResponseContentBlockLocationCitation_base: S.Struct<{
+    type: S.PropertySignature<":", "content_block_location", never, ":", "content_block_location", true, never>;
+    cited_text: typeof S.String;
+    document_index: S.filter<S.Schema<number, number, never>>;
+    document_title: S.Union<[typeof S.String, typeof S.Null]>;
+    start_block_index: S.filter<S.Schema<number, number, never>>;
+    end_block_index: typeof S.Int;
+}>;
+export declare class BetaResponseContentBlockLocationCitation extends BetaResponseContentBlockLocationCitation_base {
+}
+declare const BetaResponseTextBlock_base: S.Struct<{
+    type: S.PropertySignature<":", "text", never, ":", "text", true, never>;
+    text: S.filter<S.Schema<string, string, never>>;
+    citations: S.optionalWith<S.NullOr<S.Union<[S.Array$<S.Union<[typeof BetaResponseCharLocationCitation, typeof BetaResponsePageLocationCitation, typeof BetaResponseContentBlockLocationCitation]>>, typeof S.Null]>>, {
+        default: () => null;
+    }>;
+}>;
+export declare class BetaResponseTextBlock extends BetaResponseTextBlock_base {
+}
+declare const BetaResponseToolUseBlockType_base: S.Literal<["tool_use"]>;
+export declare class BetaResponseToolUseBlockType extends BetaResponseToolUseBlockType_base {
+}
+declare const BetaResponseToolUseBlock_base: S.Struct<{
+    type: S.PropertySignature<":", "tool_use", never, ":", "tool_use", true, never>;
+    id: S.filter<S.Schema<string, string, never>>;
+    name: S.filter<S.Schema<string, string, never>>;
+    input: S.Record$<typeof S.String, typeof S.Unknown>;
+}>;
+export declare class BetaResponseToolUseBlock extends BetaResponseToolUseBlock_base {
+}
+declare const BetaContentBlock_base: S.Union<[typeof BetaResponseTextBlock, typeof BetaResponseToolUseBlock]>;
+export declare class BetaContentBlock extends BetaContentBlock_base {
+}
+declare const BetaMessageStopReasonEnum_base: S.Literal<["end_turn", "max_tokens", "stop_sequence", "tool_use"]>;
+export declare class BetaMessageStopReasonEnum extends BetaMessageStopReasonEnum_base {
+}
+declare const BetaUsage_base: S.Struct<{
+    input_tokens: S.filter<S.Schema<number, number, never>>;
+    cache_creation_input_tokens: S.optionalWith<S.NullOr<S.Union<[S.filter<S.Schema<number, number, never>>, typeof S.Null]>>, {
+        default: () => null;
+    }>;
+    cache_read_input_tokens: S.optionalWith<S.NullOr<S.Union<[S.filter<S.Schema<number, number, never>>, typeof S.Null]>>, {
+        default: () => null;
+    }>;
+    output_tokens: S.filter<S.Schema<number, number, never>>;
+}>;
+export declare class BetaUsage extends BetaUsage_base {
+}
+declare const BetaMessage_base: S.Class<BetaMessage, {
+    id: typeof S.String;
+    type: S.PropertySignature<":", "message", never, ":", "message", true, never>;
+    role: S.PropertySignature<":", "assistant", never, ":", "assistant", true, never>;
+    content: S.Array$<typeof BetaContentBlock>;
+    model: typeof Model;
+    stop_reason: S.Union<[typeof BetaMessageStopReasonEnum, typeof S.Null]>;
+    stop_sequence: S.optionalWith<S.NullOr<S.Union<[typeof S.String, typeof S.Null]>>, {
+        default: () => null;
+    }>;
+    usage: typeof BetaUsage;
+}, S.Struct.Encoded<{
+    id: typeof S.String;
+    type: S.PropertySignature<":", "message", never, ":", "message", true, never>;
+    role: S.PropertySignature<":", "assistant", never, ":", "assistant", true, never>;
+    content: S.Array$<typeof BetaContentBlock>;
+    model: typeof Model;
+    stop_reason: S.Union<[typeof BetaMessageStopReasonEnum, typeof S.Null]>;
+    stop_sequence: S.optionalWith<S.NullOr<S.Union<[typeof S.String, typeof S.Null]>>, {
+        default: () => null;
+    }>;
+    usage: typeof BetaUsage;
+}>, never, {
+    readonly type?: "message" | undefined;
+} & {
+    readonly id: string;
+} & {
+    readonly content: readonly ({
+        readonly type: "text";
+        readonly text: string;
+        readonly citations: readonly ({
+            readonly type: "char_location";
+            readonly cited_text: string;
+            readonly document_index: number;
+            readonly document_title: string | null;
+            readonly start_char_index: number;
+            readonly end_char_index: number;
+        } | {
+            readonly type: "page_location";
+            readonly cited_text: string;
+            readonly document_index: number;
+            readonly document_title: string | null;
+            readonly start_page_number: number;
+            readonly end_page_number: number;
+        } | {
+            readonly type: "content_block_location";
+            readonly cited_text: string;
+            readonly document_index: number;
+            readonly document_title: string | null;
+            readonly start_block_index: number;
+            readonly end_block_index: number;
+        })[] | null;
+    } | {
+        readonly type: "tool_use";
+        readonly id: string;
+        readonly name: string;
+        readonly input: {
+            readonly [x: string]: unknown;
+        };
+    })[];
+} & {
+    readonly role?: "assistant" | undefined;
+} & {
+    readonly model: string;
+} & {
+    readonly stop_sequence?: string | null | undefined;
+} & {
+    readonly usage: {
+        readonly input_tokens: number;
+        readonly cache_creation_input_tokens: number | null;
+        readonly cache_read_input_tokens: number | null;
+        readonly output_tokens: number;
+    };
+} & {
+    readonly stop_reason: "tool_use" | "max_tokens" | "end_turn" | "stop_sequence" | null;
+}, {}, {}>;
+export declare class BetaMessage extends BetaMessage_base {
+}
+declare const BetaErrorResponseType_base: S.Literal<["error"]>;
+export declare class BetaErrorResponseType extends BetaErrorResponseType_base {
+}
+declare const BetaInvalidRequestErrorType_base: S.Literal<["invalid_request_error"]>;
+export declare class BetaInvalidRequestErrorType extends BetaInvalidRequestErrorType_base {
+}
+declare const BetaInvalidRequestError_base: S.Struct<{
+    type: S.PropertySignature<":", "invalid_request_error", never, ":", "invalid_request_error", true, never>;
+    message: S.PropertySignature<":", string, never, ":", string, true, never>;
+}>;
+export declare class BetaInvalidRequestError extends BetaInvalidRequestError_base {
+}
+declare const BetaAuthenticationErrorType_base: S.Literal<["authentication_error"]>;
+export declare class BetaAuthenticationErrorType extends BetaAuthenticationErrorType_base {
+}
+declare const BetaAuthenticationError_base: S.Struct<{
+    type: S.PropertySignature<":", "authentication_error", never, ":", "authentication_error", true, never>;
+    message: S.PropertySignature<":", string, never, ":", string, true, never>;
+}>;
+export declare class BetaAuthenticationError extends BetaAuthenticationError_base {
+}
+declare const BetaBillingErrorType_base: S.Literal<["billing_error"]>;
+export declare class BetaBillingErrorType extends BetaBillingErrorType_base {
+}
+declare const BetaBillingError_base: S.Struct<{
+    type: S.PropertySignature<":", "billing_error", never, ":", "billing_error", true, never>;
+    message: S.PropertySignature<":", string, never, ":", string, true, never>;
+}>;
+export declare class BetaBillingError extends BetaBillingError_base {
+}
+declare const BetaPermissionErrorType_base: S.Literal<["permission_error"]>;
+export declare class BetaPermissionErrorType extends BetaPermissionErrorType_base {
+}
+declare const BetaPermissionError_base: S.Struct<{
+    type: S.PropertySignature<":", "permission_error", never, ":", "permission_error", true, never>;
+    message: S.PropertySignature<":", string, never, ":", string, true, never>;
+}>;
+export declare class BetaPermissionError extends BetaPermissionError_base {
+}
+declare const BetaNotFoundErrorType_base: S.Literal<["not_found_error"]>;
+export declare class BetaNotFoundErrorType extends BetaNotFoundErrorType_base {
+}
+declare const BetaNotFoundError_base: S.Struct<{
+    type: S.PropertySignature<":", "not_found_error", never, ":", "not_found_error", true, never>;
+    message: S.PropertySignature<":", string, never, ":", string, true, never>;
+}>;
+export declare class BetaNotFoundError extends BetaNotFoundError_base {
+}
+declare const BetaRateLimitErrorType_base: S.Literal<["rate_limit_error"]>;
+export declare class BetaRateLimitErrorType extends BetaRateLimitErrorType_base {
+}
+declare const BetaRateLimitError_base: S.Struct<{
+    type: S.PropertySignature<":", "rate_limit_error", never, ":", "rate_limit_error", true, never>;
+    message: S.PropertySignature<":", string, never, ":", string, true, never>;
+}>;
+export declare class BetaRateLimitError extends BetaRateLimitError_base {
+}
+declare const BetaGatewayTimeoutErrorType_base: S.Literal<["timeout_error"]>;
+export declare class BetaGatewayTimeoutErrorType extends BetaGatewayTimeoutErrorType_base {
+}
+declare const BetaGatewayTimeoutError_base: S.Struct<{
+    type: S.PropertySignature<":", "timeout_error", never, ":", "timeout_error", true, never>;
+    message: S.PropertySignature<":", string, never, ":", string, true, never>;
+}>;
+export declare class BetaGatewayTimeoutError extends BetaGatewayTimeoutError_base {
+}
+declare const BetaAPIErrorType_base: S.Literal<["api_error"]>;
+export declare class BetaAPIErrorType extends BetaAPIErrorType_base {
+}
+declare const BetaAPIError_base: S.Struct<{
+    type: S.PropertySignature<":", "api_error", never, ":", "api_error", true, never>;
+    message: S.PropertySignature<":", string, never, ":", string, true, never>;
+}>;
+export declare class BetaAPIError extends BetaAPIError_base {
+}
+declare const BetaOverloadedErrorType_base: S.Literal<["overloaded_error"]>;
+export declare class BetaOverloadedErrorType extends BetaOverloadedErrorType_base {
+}
+declare const BetaOverloadedError_base: S.Struct<{
+    type: S.PropertySignature<":", "overloaded_error", never, ":", "overloaded_error", true, never>;
+    message: S.PropertySignature<":", string, never, ":", string, true, never>;
+}>;
+export declare class BetaOverloadedError extends BetaOverloadedError_base {
+}
+declare const BetaErrorResponse_base: S.Class<BetaErrorResponse, {
+    type: S.PropertySignature<":", "error", never, ":", "error", true, never>;
+    error: S.Union<[typeof BetaInvalidRequestError, typeof BetaAuthenticationError, typeof BetaBillingError, typeof BetaPermissionError, typeof BetaNotFoundError, typeof BetaRateLimitError, typeof BetaGatewayTimeoutError, typeof BetaAPIError, typeof BetaOverloadedError]>;
+}, S.Struct.Encoded<{
+    type: S.PropertySignature<":", "error", never, ":", "error", true, never>;
+    error: S.Union<[typeof BetaInvalidRequestError, typeof BetaAuthenticationError, typeof BetaBillingError, typeof BetaPermissionError, typeof BetaNotFoundError, typeof BetaRateLimitError, typeof BetaGatewayTimeoutError, typeof BetaAPIError, typeof BetaOverloadedError]>;
+}>, never, {
+    readonly type?: "error" | undefined;
+} & {
+    readonly error: {
+        readonly type: "invalid_request_error";
+        readonly message: string;
+    } | {
+        readonly type: "authentication_error";
+        readonly message: string;
+    } | {
+        readonly type: "billing_error";
+        readonly message: string;
+    } | {
+        readonly type: "permission_error";
+        readonly message: string;
+    } | {
+        readonly type: "not_found_error";
+        readonly message: string;
+    } | {
+        readonly type: "rate_limit_error";
+        readonly message: string;
+    } | {
+        readonly type: "timeout_error";
+        readonly message: string;
+    } | {
+        readonly type: "api_error";
+        readonly message: string;
+    } | {
+        readonly type: "overloaded_error";
+        readonly message: string;
+    };
+}, {}, {}>;
+export declare class BetaErrorResponse extends BetaErrorResponse_base {
+}
+declare const BetaModelsListParams_base: S.Struct<{
+    before_id: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    after_id: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    limit: S.optionalWith<S.filter<S.Schema<number, number, never>>, {
+        nullable: true;
+        default: () => 20;
+    }>;
+    "anthropic-version": S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    "x-api-key": S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+}>;
+export declare class BetaModelsListParams extends BetaModelsListParams_base {
+}
+declare const BetaModelInfoType_base: S.Literal<["model"]>;
+export declare class BetaModelInfoType extends BetaModelInfoType_base {
+}
+declare const BetaModelInfo_base: S.Struct<{
+    type: S.PropertySignature<":", "model", never, ":", "model", true, never>;
+    id: typeof S.String;
+    display_name: typeof S.String;
+    created_at: typeof S.String;
+}>;
+export declare class BetaModelInfo extends BetaModelInfo_base {
+}
+declare const BetaListResponseModelInfo_base: S.Class<BetaListResponseModelInfo, {
+    data: S.Array$<typeof BetaModelInfo>;
+    has_more: typeof S.Boolean;
+    first_id: S.Union<[typeof S.String, typeof S.Null]>;
+    last_id: S.Union<[typeof S.String, typeof S.Null]>;
+}, S.Struct.Encoded<{
+    data: S.Array$<typeof BetaModelInfo>;
+    has_more: typeof S.Boolean;
+    first_id: S.Union<[typeof S.String, typeof S.Null]>;
+    last_id: S.Union<[typeof S.String, typeof S.Null]>;
+}>, never, {
+    readonly data: readonly {
+        readonly type: "model";
+        readonly id: string;
+        readonly display_name: string;
+        readonly created_at: string;
+    }[];
+} & {
+    readonly has_more: boolean;
+} & {
+    readonly first_id: string | null;
+} & {
+    readonly last_id: string | null;
+}, {}, {}>;
+export declare class BetaListResponseModelInfo extends BetaListResponseModelInfo_base {
+}
+declare const BetaModelsGetParams_base: S.Struct<{
+    "anthropic-version": S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    "x-api-key": S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+}>;
+export declare class BetaModelsGetParams extends BetaModelsGetParams_base {
+}
+declare const BetaMessageBatchesListParams_base: S.Struct<{
+    before_id: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    after_id: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    limit: S.optionalWith<S.filter<S.Schema<number, number, never>>, {
+        nullable: true;
+        default: () => 20;
+    }>;
+    "anthropic-beta": S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    "anthropic-version": S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    "x-api-key": S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+}>;
+export declare class BetaMessageBatchesListParams extends BetaMessageBatchesListParams_base {
+}
+declare const BetaMessageBatchType_base: S.Literal<["message_batch"]>;
+export declare class BetaMessageBatchType extends BetaMessageBatchType_base {
+}
+declare const BetaMessageBatchProcessingStatus_base: S.Literal<["in_progress", "canceling", "ended"]>;
+export declare class BetaMessageBatchProcessingStatus extends BetaMessageBatchProcessingStatus_base {
+}
+declare const BetaRequestCounts_base: S.Struct<{
+    processing: S.PropertySignature<":", number, never, ":", number, true, never>;
+    succeeded: S.PropertySignature<":", number, never, ":", number, true, never>;
+    errored: S.PropertySignature<":", number, never, ":", number, true, never>;
+    canceled: S.PropertySignature<":", number, never, ":", number, true, never>;
+    expired: S.PropertySignature<":", number, never, ":", number, true, never>;
+}>;
+export declare class BetaRequestCounts extends BetaRequestCounts_base {
+}
+declare const BetaMessageBatch_base: S.Struct<{
+    id: typeof S.String;
+    type: S.PropertySignature<":", "message_batch", never, ":", "message_batch", true, never>;
+    processing_status: typeof BetaMessageBatchProcessingStatus;
+    request_counts: typeof BetaRequestCounts;
+    ended_at: S.Union<[typeof S.String, typeof S.Null]>;
+    created_at: typeof S.String;
+    expires_at: typeof S.String;
+    archived_at: S.Union<[typeof S.String, typeof S.Null]>;
+    cancel_initiated_at: S.Union<[typeof S.String, typeof S.Null]>;
+    results_url: S.Union<[typeof S.String, typeof S.Null]>;
+}>;
+export declare class BetaMessageBatch extends BetaMessageBatch_base {
+}
+declare const BetaListResponseMessageBatch_base: S.Class<BetaListResponseMessageBatch, {
+    data: S.Array$<typeof BetaMessageBatch>;
+    has_more: typeof S.Boolean;
+    first_id: S.Union<[typeof S.String, typeof S.Null]>;
+    last_id: S.Union<[typeof S.String, typeof S.Null]>;
+}, S.Struct.Encoded<{
+    data: S.Array$<typeof BetaMessageBatch>;
+    has_more: typeof S.Boolean;
+    first_id: S.Union<[typeof S.String, typeof S.Null]>;
+    last_id: S.Union<[typeof S.String, typeof S.Null]>;
+}>, never, {
+    readonly data: readonly {
+        readonly type: "message_batch";
+        readonly id: string;
+        readonly created_at: string;
+        readonly processing_status: "in_progress" | "canceling" | "ended";
+        readonly request_counts: {
+            readonly processing: number;
+            readonly succeeded: number;
+            readonly errored: number;
+            readonly canceled: number;
+            readonly expired: number;
+        };
+        readonly ended_at: string | null;
+        readonly expires_at: string;
+        readonly archived_at: string | null;
+        readonly cancel_initiated_at: string | null;
+        readonly results_url: string | null;
+    }[];
+} & {
+    readonly has_more: boolean;
+} & {
+    readonly first_id: string | null;
+} & {
+    readonly last_id: string | null;
+}, {}, {}>;
+export declare class BetaListResponseMessageBatch extends BetaListResponseMessageBatch_base {
+}
+declare const BetaMessageBatchesPostParams_base: S.Struct<{
+    "anthropic-beta": S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    "anthropic-version": S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+}>;
+export declare class BetaMessageBatchesPostParams extends BetaMessageBatchesPostParams_base {
+}
+declare const BetaMessageBatchIndividualRequestParams_base: S.Struct<{
+    custom_id: S.filter<S.Schema<string, string, never>>;
+    params: typeof BetaCreateMessageParams;
+}>;
+export declare class BetaMessageBatchIndividualRequestParams extends BetaMessageBatchIndividualRequestParams_base {
+}
+declare const BetaCreateMessageBatchParams_base: S.Class<BetaCreateMessageBatchParams, {
+    requests: S.filter<S.Schema<readonly {
+        readonly custom_id: string;
+        readonly params: BetaCreateMessageParams;
+    }[], readonly {
+        readonly custom_id: string;
+        readonly params: {
+            readonly model: string;
+            readonly messages: readonly {
+                readonly content: string | readonly ({
+                    readonly type: "text";
+                    readonly text: string;
+                    readonly cache_control?: {
+                        readonly type: "ephemeral";
+                    } | null | undefined;
+                    readonly citations?: readonly ({
+                        readonly type: "char_location";
+                        readonly cited_text: string;
+                        readonly document_index: number;
+                        readonly document_title: string | null;
+                        readonly start_char_index: number;
+                        readonly end_char_index: number;
+                    } | {
+                        readonly type: "page_location";
+                        readonly cited_text: string;
+                        readonly document_index: number;
+                        readonly document_title: string | null;
+                        readonly start_page_number: number;
+                        readonly end_page_number: number;
+                    } | {
+                        readonly type: "content_block_location";
+                        readonly cited_text: string;
+                        readonly document_index: number;
+                        readonly document_title: string | null;
+                        readonly start_block_index: number;
+                        readonly end_block_index: number;
+                    })[] | null | undefined;
+                } | {
+                    readonly type: "image";
+                    readonly source: {
+                        readonly type: "base64";
+                        readonly media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+                        readonly data: string;
+                    };
+                    readonly cache_control?: {
+                        readonly type: "ephemeral";
+                    } | null | undefined;
+                } | {
+                    readonly type: "tool_use";
+                    readonly id: string;
+                    readonly name: string;
+                    readonly input: {
+                        readonly [x: string]: unknown;
+                    };
+                    readonly cache_control?: {
+                        readonly type: "ephemeral";
+                    } | null | undefined;
+                } | {
+                    readonly type: "tool_result";
+                    readonly tool_use_id: string;
+                    readonly cache_control?: {
+                        readonly type: "ephemeral";
+                    } | null | undefined;
+                    readonly is_error?: boolean | null | undefined;
+                    readonly content?: string | readonly ({
+                        readonly type: "text";
+                        readonly text: string;
+                        readonly cache_control?: {
+                            readonly type: "ephemeral";
+                        } | null | undefined;
+                        readonly citations?: readonly ({
+                            readonly type: "char_location";
+                            readonly cited_text: string;
+                            readonly document_index: number;
+                            readonly document_title: string | null;
+                            readonly start_char_index: number;
+                            readonly end_char_index: number;
+                        } | {
+                            readonly type: "page_location";
+                            readonly cited_text: string;
+                            readonly document_index: number;
+                            readonly document_title: string | null;
+                            readonly start_page_number: number;
+                            readonly end_page_number: number;
+                        } | {
+                            readonly type: "content_block_location";
+                            readonly cited_text: string;
+                            readonly document_index: number;
+                            readonly document_title: string | null;
+                            readonly start_block_index: number;
+                            readonly end_block_index: number;
+                        })[] | null | undefined;
+                    } | {
+                        readonly type: "image";
+                        readonly source: {
+                            readonly type: "base64";
+                            readonly media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+                            readonly data: string;
+                        };
+                        readonly cache_control?: {
+                            readonly type: "ephemeral";
+                        } | null | undefined;
+                    })[] | null | undefined;
+                } | {
+                    readonly type: "document";
+                    readonly source: {
+                        readonly type: "base64";
+                        readonly media_type: "application/pdf";
+                        readonly data: string;
+                    } | {
+                        readonly type: "text";
+                        readonly media_type: "text/plain";
+                        readonly data: string;
+                    } | {
+                        readonly type: "content";
+                        readonly content: string | readonly ({
+                            readonly type: "text";
+                            readonly text: string;
+                            readonly cache_control?: {
+                                readonly type: "ephemeral";
+                            } | null | undefined;
+                            readonly citations?: readonly ({
+                                readonly type: "char_location";
+                                readonly cited_text: string;
+                                readonly document_index: number;
+                                readonly document_title: string | null;
+                                readonly start_char_index: number;
+                                readonly end_char_index: number;
+                            } | {
+                                readonly type: "page_location";
+                                readonly cited_text: string;
+                                readonly document_index: number;
+                                readonly document_title: string | null;
+                                readonly start_page_number: number;
+                                readonly end_page_number: number;
+                            } | {
+                                readonly type: "content_block_location";
+                                readonly cited_text: string;
+                                readonly document_index: number;
+                                readonly document_title: string | null;
+                                readonly start_block_index: number;
+                                readonly end_block_index: number;
+                            })[] | null | undefined;
+                        } | {
+                            readonly type: "image";
+                            readonly source: {
+                                readonly type: "base64";
+                                readonly media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+                                readonly data: string;
+                            };
+                            readonly cache_control?: {
+                                readonly type: "ephemeral";
+                            } | null | undefined;
+                        })[];
+                    };
+                    readonly cache_control?: {
+                        readonly type: "ephemeral";
+                    } | null | undefined;
+                    readonly citations?: {
+                        readonly enabled?: boolean | null | undefined;
+                    } | null | undefined;
+                    readonly title?: string | null | undefined;
+                    readonly context?: string | null | undefined;
+                })[];
+                readonly role: "user" | "assistant";
+            }[];
+            readonly max_tokens: number;
+            readonly metadata?: {
+                readonly user_id?: string | null | undefined;
+            } | null | undefined;
+            readonly stop_sequences?: readonly string[] | null | undefined;
+            readonly stream?: boolean | null | undefined;
+            readonly system?: string | readonly {
+                readonly type: "text";
+                readonly text: string;
+                readonly cache_control?: {
+                    readonly type: "ephemeral";
+                } | null | undefined;
+                readonly citations?: readonly ({
+                    readonly type: "char_location";
+                    readonly cited_text: string;
+                    readonly document_index: number;
+                    readonly document_title: string | null;
+                    readonly start_char_index: number;
+                    readonly end_char_index: number;
+                } | {
+                    readonly type: "page_location";
+                    readonly cited_text: string;
+                    readonly document_index: number;
+                    readonly document_title: string | null;
+                    readonly start_page_number: number;
+                    readonly end_page_number: number;
+                } | {
+                    readonly type: "content_block_location";
+                    readonly cited_text: string;
+                    readonly document_index: number;
+                    readonly document_title: string | null;
+                    readonly start_block_index: number;
+                    readonly end_block_index: number;
+                })[] | null | undefined;
+            }[] | null | undefined;
+            readonly temperature?: number | null | undefined;
+            readonly tool_choice?: {
+                readonly type: "auto";
+                readonly disable_parallel_tool_use?: boolean | null | undefined;
+            } | {
+                readonly type: "any";
+                readonly disable_parallel_tool_use?: boolean | null | undefined;
+            } | {
+                readonly type: "tool";
+                readonly name: string;
+                readonly disable_parallel_tool_use?: boolean | null | undefined;
+            } | null | undefined;
+            readonly tools?: readonly ({
+                readonly name: string;
+                readonly input_schema: {
+                    readonly type: "object";
+                    readonly properties?: {
+                        readonly [x: string]: unknown;
+                    } | null | undefined;
+                };
+                readonly type?: "custom" | null | undefined;
+                readonly cache_control?: {
+                    readonly type: "ephemeral";
+                } | null | undefined;
+                readonly description?: string | null | undefined;
+            } | {
+                readonly type: "computer_20241022";
+                readonly name: "computer";
+                readonly display_height_px: number;
+                readonly display_width_px: number;
+                readonly cache_control?: {
+                    readonly type: "ephemeral";
+                } | null | undefined;
+                readonly display_number?: number | null | undefined;
+            } | {
+                readonly type: "bash_20241022";
+                readonly name: "bash";
+                readonly cache_control?: {
+                    readonly type: "ephemeral";
+                } | null | undefined;
+            } | {
+                readonly type: "text_editor_20241022";
+                readonly name: "str_replace_editor";
+                readonly cache_control?: {
+                    readonly type: "ephemeral";
+                } | null | undefined;
+            })[] | null | undefined;
+            readonly top_k?: number | null | undefined;
+            readonly top_p?: number | null | undefined;
+        };
+    }[], never>>;
+}, S.Struct.Encoded<{
+    requests: S.filter<S.Schema<readonly {
+        readonly custom_id: string;
+        readonly params: BetaCreateMessageParams;
+    }[], readonly {
+        readonly custom_id: string;
+        readonly params: {
+            readonly model: string;
+            readonly messages: readonly {
+                readonly content: string | readonly ({
+                    readonly type: "text";
+                    readonly text: string;
+                    readonly cache_control?: {
+                        readonly type: "ephemeral";
+                    } | null | undefined;
+                    readonly citations?: readonly ({
+                        readonly type: "char_location";
+                        readonly cited_text: string;
+                        readonly document_index: number;
+                        readonly document_title: string | null;
+                        readonly start_char_index: number;
+                        readonly end_char_index: number;
+                    } | {
+                        readonly type: "page_location";
+                        readonly cited_text: string;
+                        readonly document_index: number;
+                        readonly document_title: string | null;
+                        readonly start_page_number: number;
+                        readonly end_page_number: number;
+                    } | {
+                        readonly type: "content_block_location";
+                        readonly cited_text: string;
+                        readonly document_index: number;
+                        readonly document_title: string | null;
+                        readonly start_block_index: number;
+                        readonly end_block_index: number;
+                    })[] | null | undefined;
+                } | {
+                    readonly type: "image";
+                    readonly source: {
+                        readonly type: "base64";
+                        readonly media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+                        readonly data: string;
+                    };
+                    readonly cache_control?: {
+                        readonly type: "ephemeral";
+                    } | null | undefined;
+                } | {
+                    readonly type: "tool_use";
+                    readonly id: string;
+                    readonly name: string;
+                    readonly input: {
+                        readonly [x: string]: unknown;
+                    };
+                    readonly cache_control?: {
+                        readonly type: "ephemeral";
+                    } | null | undefined;
+                } | {
+                    readonly type: "tool_result";
+                    readonly tool_use_id: string;
+                    readonly cache_control?: {
+                        readonly type: "ephemeral";
+                    } | null | undefined;
+                    readonly is_error?: boolean | null | undefined;
+                    readonly content?: string | readonly ({
+                        readonly type: "text";
+                        readonly text: string;
+                        readonly cache_control?: {
+                            readonly type: "ephemeral";
+                        } | null | undefined;
+                        readonly citations?: readonly ({
+                            readonly type: "char_location";
+                            readonly cited_text: string;
+                            readonly document_index: number;
+                            readonly document_title: string | null;
+                            readonly start_char_index: number;
+                            readonly end_char_index: number;
+                        } | {
+                            readonly type: "page_location";
+                            readonly cited_text: string;
+                            readonly document_index: number;
+                            readonly document_title: string | null;
+                            readonly start_page_number: number;
+                            readonly end_page_number: number;
+                        } | {
+                            readonly type: "content_block_location";
+                            readonly cited_text: string;
+                            readonly document_index: number;
+                            readonly document_title: string | null;
+                            readonly start_block_index: number;
+                            readonly end_block_index: number;
+                        })[] | null | undefined;
+                    } | {
+                        readonly type: "image";
+                        readonly source: {
+                            readonly type: "base64";
+                            readonly media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+                            readonly data: string;
+                        };
+                        readonly cache_control?: {
+                            readonly type: "ephemeral";
+                        } | null | undefined;
+                    })[] | null | undefined;
+                } | {
+                    readonly type: "document";
+                    readonly source: {
+                        readonly type: "base64";
+                        readonly media_type: "application/pdf";
+                        readonly data: string;
+                    } | {
+                        readonly type: "text";
+                        readonly media_type: "text/plain";
+                        readonly data: string;
+                    } | {
+                        readonly type: "content";
+                        readonly content: string | readonly ({
+                            readonly type: "text";
+                            readonly text: string;
+                            readonly cache_control?: {
+                                readonly type: "ephemeral";
+                            } | null | undefined;
+                            readonly citations?: readonly ({
+                                readonly type: "char_location";
+                                readonly cited_text: string;
+                                readonly document_index: number;
+                                readonly document_title: string | null;
+                                readonly start_char_index: number;
+                                readonly end_char_index: number;
+                            } | {
+                                readonly type: "page_location";
+                                readonly cited_text: string;
+                                readonly document_index: number;
+                                readonly document_title: string | null;
+                                readonly start_page_number: number;
+                                readonly end_page_number: number;
+                            } | {
+                                readonly type: "content_block_location";
+                                readonly cited_text: string;
+                                readonly document_index: number;
+                                readonly document_title: string | null;
+                                readonly start_block_index: number;
+                                readonly end_block_index: number;
+                            })[] | null | undefined;
+                        } | {
+                            readonly type: "image";
+                            readonly source: {
+                                readonly type: "base64";
+                                readonly media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+                                readonly data: string;
+                            };
+                            readonly cache_control?: {
+                                readonly type: "ephemeral";
+                            } | null | undefined;
+                        })[];
+                    };
+                    readonly cache_control?: {
+                        readonly type: "ephemeral";
+                    } | null | undefined;
+                    readonly citations?: {
+                        readonly enabled?: boolean | null | undefined;
+                    } | null | undefined;
+                    readonly title?: string | null | undefined;
+                    readonly context?: string | null | undefined;
+                })[];
+                readonly role: "user" | "assistant";
+            }[];
+            readonly max_tokens: number;
+            readonly metadata?: {
+                readonly user_id?: string | null | undefined;
+            } | null | undefined;
+            readonly stop_sequences?: readonly string[] | null | undefined;
+            readonly stream?: boolean | null | undefined;
+            readonly system?: string | readonly {
+                readonly type: "text";
+                readonly text: string;
+                readonly cache_control?: {
+                    readonly type: "ephemeral";
+                } | null | undefined;
+                readonly citations?: readonly ({
+                    readonly type: "char_location";
+                    readonly cited_text: string;
+                    readonly document_index: number;
+                    readonly document_title: string | null;
+                    readonly start_char_index: number;
+                    readonly end_char_index: number;
+                } | {
+                    readonly type: "page_location";
+                    readonly cited_text: string;
+                    readonly document_index: number;
+                    readonly document_title: string | null;
+                    readonly start_page_number: number;
+                    readonly end_page_number: number;
+                } | {
+                    readonly type: "content_block_location";
+                    readonly cited_text: string;
+                    readonly document_index: number;
+                    readonly document_title: string | null;
+                    readonly start_block_index: number;
+                    readonly end_block_index: number;
+                })[] | null | undefined;
+            }[] | null | undefined;
+            readonly temperature?: number | null | undefined;
+            readonly tool_choice?: {
+                readonly type: "auto";
+                readonly disable_parallel_tool_use?: boolean | null | undefined;
+            } | {
+                readonly type: "any";
+                readonly disable_parallel_tool_use?: boolean | null | undefined;
+            } | {
+                readonly type: "tool";
+                readonly name: string;
+                readonly disable_parallel_tool_use?: boolean | null | undefined;
+            } | null | undefined;
+            readonly tools?: readonly ({
+                readonly name: string;
+                readonly input_schema: {
+                    readonly type: "object";
+                    readonly properties?: {
+                        readonly [x: string]: unknown;
+                    } | null | undefined;
+                };
+                readonly type?: "custom" | null | undefined;
+                readonly cache_control?: {
+                    readonly type: "ephemeral";
+                } | null | undefined;
+                readonly description?: string | null | undefined;
+            } | {
+                readonly type: "computer_20241022";
+                readonly name: "computer";
+                readonly display_height_px: number;
+                readonly display_width_px: number;
+                readonly cache_control?: {
+                    readonly type: "ephemeral";
+                } | null | undefined;
+                readonly display_number?: number | null | undefined;
+            } | {
+                readonly type: "bash_20241022";
+                readonly name: "bash";
+                readonly cache_control?: {
+                    readonly type: "ephemeral";
+                } | null | undefined;
+            } | {
+                readonly type: "text_editor_20241022";
+                readonly name: "str_replace_editor";
+                readonly cache_control?: {
+                    readonly type: "ephemeral";
+                } | null | undefined;
+            })[] | null | undefined;
+            readonly top_k?: number | null | undefined;
+            readonly top_p?: number | null | undefined;
+        };
+    }[], never>>;
+}>, never, {
+    readonly requests: readonly {
+        readonly custom_id: string;
+        readonly params: BetaCreateMessageParams;
+    }[];
+}, {}, {}>;
+export declare class BetaCreateMessageBatchParams extends BetaCreateMessageBatchParams_base {
+}
+declare const BetaMessageBatchesRetrieveParams_base: S.Struct<{
+    "anthropic-beta": S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    "anthropic-version": S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    "x-api-key": S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+}>;
+export declare class BetaMessageBatchesRetrieveParams extends BetaMessageBatchesRetrieveParams_base {
+}
+declare const BetaMessageBatchesDeleteParams_base: S.Struct<{
+    "anthropic-beta": S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    "anthropic-version": S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    "x-api-key": S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+}>;
+export declare class BetaMessageBatchesDeleteParams extends BetaMessageBatchesDeleteParams_base {
+}
+declare const BetaDeleteMessageBatchResponseType_base: S.Literal<["message_batch_deleted"]>;
+export declare class BetaDeleteMessageBatchResponseType extends BetaDeleteMessageBatchResponseType_base {
+}
+declare const BetaDeleteMessageBatchResponse_base: S.Class<BetaDeleteMessageBatchResponse, {
+    id: typeof S.String;
+    type: S.PropertySignature<":", "message_batch_deleted", never, ":", "message_batch_deleted", true, never>;
+}, S.Struct.Encoded<{
+    id: typeof S.String;
+    type: S.PropertySignature<":", "message_batch_deleted", never, ":", "message_batch_deleted", true, never>;
+}>, never, {
+    readonly type?: "message_batch_deleted" | undefined;
+} & {
+    readonly id: string;
+}, {}, {}>;
+export declare class BetaDeleteMessageBatchResponse extends BetaDeleteMessageBatchResponse_base {
+}
+declare const BetaMessageBatchesCancelParams_base: S.Struct<{
+    "anthropic-beta": S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    "anthropic-version": S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+}>;
+export declare class BetaMessageBatchesCancelParams extends BetaMessageBatchesCancelParams_base {
+}
+declare const BetaMessageBatchesResultsParams_base: S.Struct<{
+    "anthropic-beta": S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    "anthropic-version": S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    "x-api-key": S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+}>;
+export declare class BetaMessageBatchesResultsParams extends BetaMessageBatchesResultsParams_base {
+}
+declare const BetaMessagesCountTokensPostParams_base: S.Struct<{
+    "anthropic-beta": S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    "anthropic-version": S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+}>;
+export declare class BetaMessagesCountTokensPostParams extends BetaMessagesCountTokensPostParams_base {
+}
+declare const BetaCountMessageTokensParams_base: S.Class<BetaCountMessageTokensParams, {
+    tool_choice: S.optionalWith<typeof BetaToolChoice, {
+        nullable: true;
+    }>;
+    tools: S.optionalWith<S.Array$<S.Union<[typeof BetaTool, typeof BetaComputerUseTool20241022, typeof BetaBashTool20241022, typeof BetaTextEditor20241022]>>, {
+        nullable: true;
+    }>;
+    messages: S.Array$<typeof BetaInputMessage>;
+    system: S.optionalWith<S.Union<[typeof S.String, S.Array$<typeof BetaRequestTextBlock>]>, {
+        nullable: true;
+    }>;
+    model: typeof Model;
+}, S.Struct.Encoded<{
+    tool_choice: S.optionalWith<typeof BetaToolChoice, {
+        nullable: true;
+    }>;
+    tools: S.optionalWith<S.Array$<S.Union<[typeof BetaTool, typeof BetaComputerUseTool20241022, typeof BetaBashTool20241022, typeof BetaTextEditor20241022]>>, {
+        nullable: true;
+    }>;
+    messages: S.Array$<typeof BetaInputMessage>;
+    system: S.optionalWith<S.Union<[typeof S.String, S.Array$<typeof BetaRequestTextBlock>]>, {
+        nullable: true;
+    }>;
+    model: typeof Model;
+}>, never, {
+    readonly model: string;
+} & {
+    readonly messages: readonly {
+        readonly content: string | readonly ({
+            readonly type: "text";
+            readonly text: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+            } | null | undefined;
+            readonly citations?: readonly ({
+                readonly type: "char_location";
+                readonly cited_text: string;
+                readonly document_index: number;
+                readonly document_title: string | null;
+                readonly start_char_index: number;
+                readonly end_char_index: number;
+            } | {
+                readonly type: "page_location";
+                readonly cited_text: string;
+                readonly document_index: number;
+                readonly document_title: string | null;
+                readonly start_page_number: number;
+                readonly end_page_number: number;
+            } | {
+                readonly type: "content_block_location";
+                readonly cited_text: string;
+                readonly document_index: number;
+                readonly document_title: string | null;
+                readonly start_block_index: number;
+                readonly end_block_index: number;
+            })[] | null | undefined;
+        } | {
+            readonly type: "image";
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+            } | null | undefined;
+            readonly source: {
+                readonly type: "base64";
+                readonly media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+                readonly data: string;
+            };
+        } | {
+            readonly type: "tool_use";
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+            } | null | undefined;
+            readonly id: string;
+            readonly name: string;
+            readonly input: {
+                readonly [x: string]: unknown;
+            };
+        } | {
+            readonly type: "tool_result";
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+            } | null | undefined;
+            readonly tool_use_id: string;
+            readonly is_error?: boolean | undefined;
+            readonly content?: string | readonly ({
+                readonly type: "text";
+                readonly text: string;
+                readonly cache_control?: {
+                    readonly type: "ephemeral";
+                } | null | undefined;
+                readonly citations?: readonly ({
+                    readonly type: "char_location";
+                    readonly cited_text: string;
+                    readonly document_index: number;
+                    readonly document_title: string | null;
+                    readonly start_char_index: number;
+                    readonly end_char_index: number;
+                } | {
+                    readonly type: "page_location";
+                    readonly cited_text: string;
+                    readonly document_index: number;
+                    readonly document_title: string | null;
+                    readonly start_page_number: number;
+                    readonly end_page_number: number;
+                } | {
+                    readonly type: "content_block_location";
+                    readonly cited_text: string;
+                    readonly document_index: number;
+                    readonly document_title: string | null;
+                    readonly start_block_index: number;
+                    readonly end_block_index: number;
+                })[] | null | undefined;
+            } | {
+                readonly type: "image";
+                readonly cache_control?: {
+                    readonly type: "ephemeral";
+                } | null | undefined;
+                readonly source: {
+                    readonly type: "base64";
+                    readonly media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+                    readonly data: string;
+                };
+            })[] | undefined;
+        } | {
+            readonly type: "document";
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+            } | null | undefined;
+            readonly citations?: {
+                readonly enabled?: boolean | undefined;
+            } | undefined;
+            readonly source: {
+                readonly type: "base64";
+                readonly media_type: "application/pdf";
+                readonly data: string;
+            } | {
+                readonly type: "text";
+                readonly media_type: "text/plain";
+                readonly data: string;
+            } | {
+                readonly type: "content";
+                readonly content: string | readonly ({
+                    readonly type: "text";
+                    readonly text: string;
+                    readonly cache_control?: {
+                        readonly type: "ephemeral";
+                    } | null | undefined;
+                    readonly citations?: readonly ({
+                        readonly type: "char_location";
+                        readonly cited_text: string;
+                        readonly document_index: number;
+                        readonly document_title: string | null;
+                        readonly start_char_index: number;
+                        readonly end_char_index: number;
+                    } | {
+                        readonly type: "page_location";
+                        readonly cited_text: string;
+                        readonly document_index: number;
+                        readonly document_title: string | null;
+                        readonly start_page_number: number;
+                        readonly end_page_number: number;
+                    } | {
+                        readonly type: "content_block_location";
+                        readonly cited_text: string;
+                        readonly document_index: number;
+                        readonly document_title: string | null;
+                        readonly start_block_index: number;
+                        readonly end_block_index: number;
+                    })[] | null | undefined;
+                } | {
+                    readonly type: "image";
+                    readonly cache_control?: {
+                        readonly type: "ephemeral";
+                    } | null | undefined;
+                    readonly source: {
+                        readonly type: "base64";
+                        readonly media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+                        readonly data: string;
+                    };
+                })[];
+            };
+            readonly title?: string | null | undefined;
+            readonly context?: string | null | undefined;
+        })[];
+        readonly role: "user" | "assistant";
+    }[];
+} & {
+    readonly system?: string | readonly {
+        readonly type: "text";
+        readonly text: string;
+        readonly cache_control?: {
+            readonly type: "ephemeral";
+        } | null | undefined;
+        readonly citations?: readonly ({
+            readonly type: "char_location";
+            readonly cited_text: string;
+            readonly document_index: number;
+            readonly document_title: string | null;
+            readonly start_char_index: number;
+            readonly end_char_index: number;
+        } | {
+            readonly type: "page_location";
+            readonly cited_text: string;
+            readonly document_index: number;
+            readonly document_title: string | null;
+            readonly start_page_number: number;
+            readonly end_page_number: number;
+        } | {
+            readonly type: "content_block_location";
+            readonly cited_text: string;
+            readonly document_index: number;
+            readonly document_title: string | null;
+            readonly start_block_index: number;
+            readonly end_block_index: number;
+        })[] | null | undefined;
+    }[] | undefined;
+} & {
+    readonly tool_choice?: {
+        readonly type: "auto";
+        readonly disable_parallel_tool_use?: boolean | undefined;
+    } | {
+        readonly type: "any";
+        readonly disable_parallel_tool_use?: boolean | undefined;
+    } | {
+        readonly type: "tool";
+        readonly name: string;
+        readonly disable_parallel_tool_use?: boolean | undefined;
+    } | undefined;
+} & {
+    readonly tools?: readonly ({
+        readonly type?: "custom" | null | undefined;
+        readonly cache_control?: {
+            readonly type: "ephemeral";
+        } | null | undefined;
+        readonly name: string;
+        readonly description?: string | undefined;
+        readonly input_schema: {
+            readonly type: "object";
+            readonly properties?: {
+                readonly [x: string]: unknown;
+            } | null | undefined;
+        };
+    } | {
+        readonly type: "computer_20241022";
+        readonly cache_control?: {
+            readonly type: "ephemeral";
+        } | null | undefined;
+        readonly name: "computer";
+        readonly display_height_px: number;
+        readonly display_width_px: number;
+        readonly display_number?: number | null | undefined;
+    } | {
+        readonly type: "bash_20241022";
+        readonly cache_control?: {
+            readonly type: "ephemeral";
+        } | null | undefined;
+        readonly name: "bash";
+    } | {
+        readonly type: "text_editor_20241022";
+        readonly cache_control?: {
+            readonly type: "ephemeral";
+        } | null | undefined;
+        readonly name: "str_replace_editor";
+    })[] | undefined;
+}, {}, {}>;
+export declare class BetaCountMessageTokensParams extends BetaCountMessageTokensParams_base {
+}
+declare const BetaCountMessageTokensResponse_base: S.Class<BetaCountMessageTokensResponse, {
+    input_tokens: typeof S.Int;
+}, S.Struct.Encoded<{
+    input_tokens: typeof S.Int;
+}>, never, {
+    readonly input_tokens: number;
+}, {}, {}>;
+export declare class BetaCountMessageTokensResponse extends BetaCountMessageTokensResponse_base {
+}
+export declare const make: (httpClient: HttpClient.HttpClient, options?: {
+    readonly transformClient?: ((client: HttpClient.HttpClient) => Effect.Effect<HttpClient.HttpClient>) | undefined;
+}) => Client;
+export interface Client {
+    readonly "messagesPost": (options: {
+        readonly params: typeof MessagesPostParams.Encoded;
+        readonly payload: typeof CreateMessageParams.Encoded;
+    }) => Effect.Effect<typeof Message.Type, HttpClientError.HttpClientError | ParseError | typeof ErrorResponse.Type>;
+    readonly "completePost": (options: {
+        readonly params: typeof CompletePostParams.Encoded;
+        readonly payload: typeof CompletionRequest.Encoded;
+    }) => Effect.Effect<typeof CompletionResponse.Type, HttpClientError.HttpClientError | ParseError | typeof ErrorResponse.Type>;
+    readonly "modelsList": (options: typeof ModelsListParams.Encoded) => Effect.Effect<typeof ListResponseModelInfo.Type, HttpClientError.HttpClientError | ParseError | typeof ErrorResponse.Type>;
+    readonly "modelsGet": (modelId: string, options: typeof ModelsGetParams.Encoded) => Effect.Effect<typeof ModelInfo.Type, HttpClientError.HttpClientError | ParseError | typeof ErrorResponse.Type>;
+    readonly "messageBatchesList": (options: typeof MessageBatchesListParams.Encoded) => Effect.Effect<typeof ListResponseMessageBatch.Type, HttpClientError.HttpClientError | ParseError | typeof ErrorResponse.Type>;
+    readonly "messageBatchesPost": (options: {
+        readonly params: typeof MessageBatchesPostParams.Encoded;
+        readonly payload: typeof CreateMessageBatchParams.Encoded;
+    }) => Effect.Effect<typeof MessageBatch.Type, HttpClientError.HttpClientError | ParseError | typeof ErrorResponse.Type>;
+    readonly "messageBatchesRetrieve": (messageBatchId: string, options: typeof MessageBatchesRetrieveParams.Encoded) => Effect.Effect<typeof MessageBatch.Type, HttpClientError.HttpClientError | ParseError | typeof ErrorResponse.Type>;
+    readonly "messageBatchesDelete": (messageBatchId: string, options: typeof MessageBatchesDeleteParams.Encoded) => Effect.Effect<typeof DeleteMessageBatchResponse.Type, HttpClientError.HttpClientError | ParseError | typeof ErrorResponse.Type>;
+    readonly "messageBatchesCancel": (messageBatchId: string, options: typeof MessageBatchesCancelParams.Encoded) => Effect.Effect<typeof MessageBatch.Type, HttpClientError.HttpClientError | ParseError | typeof ErrorResponse.Type>;
+    readonly "messageBatchesResults": (messageBatchId: string, options: typeof MessageBatchesResultsParams.Encoded) => Effect.Effect<void, HttpClientError.HttpClientError | ParseError | typeof ErrorResponse.Type>;
+    readonly "messagesCountTokensPost": (options: {
+        readonly params: typeof MessagesCountTokensPostParams.Encoded;
+        readonly payload: typeof CountMessageTokensParams.Encoded;
+    }) => Effect.Effect<typeof CountMessageTokensResponse.Type, HttpClientError.HttpClientError | ParseError | typeof ErrorResponse.Type>;
+    readonly "betaMessagesPost": (options: {
+        readonly params: typeof BetaMessagesPostParams.Encoded;
+        readonly payload: typeof BetaCreateMessageParams.Encoded;
+    }) => Effect.Effect<typeof BetaMessage.Type, HttpClientError.HttpClientError | ParseError | typeof BetaErrorResponse.Type>;
+    readonly "betaModelsList": (options: typeof BetaModelsListParams.Encoded) => Effect.Effect<typeof BetaListResponseModelInfo.Type, HttpClientError.HttpClientError | ParseError | typeof BetaErrorResponse.Type>;
+    readonly "betaModelsGet": (modelId: string, options: typeof BetaModelsGetParams.Encoded) => Effect.Effect<typeof BetaModelInfo.Type, HttpClientError.HttpClientError | ParseError | typeof BetaErrorResponse.Type>;
+    readonly "betaMessageBatchesList": (options: typeof BetaMessageBatchesListParams.Encoded) => Effect.Effect<typeof BetaListResponseMessageBatch.Type, HttpClientError.HttpClientError | ParseError | typeof BetaErrorResponse.Type>;
+    readonly "betaMessageBatchesPost": (options: {
+        readonly params: typeof BetaMessageBatchesPostParams.Encoded;
+        readonly payload: typeof BetaCreateMessageBatchParams.Encoded;
+    }) => Effect.Effect<typeof BetaMessageBatch.Type, HttpClientError.HttpClientError | ParseError | typeof BetaErrorResponse.Type>;
+    readonly "betaMessageBatchesRetrieve": (messageBatchId: string, options: typeof BetaMessageBatchesRetrieveParams.Encoded) => Effect.Effect<typeof BetaMessageBatch.Type, HttpClientError.HttpClientError | ParseError | typeof BetaErrorResponse.Type>;
+    readonly "betaMessageBatchesDelete": (messageBatchId: string, options: typeof BetaMessageBatchesDeleteParams.Encoded) => Effect.Effect<typeof BetaDeleteMessageBatchResponse.Type, HttpClientError.HttpClientError | ParseError | typeof BetaErrorResponse.Type>;
+    readonly "betaMessageBatchesCancel": (messageBatchId: string, options: typeof BetaMessageBatchesCancelParams.Encoded) => Effect.Effect<typeof BetaMessageBatch.Type, HttpClientError.HttpClientError | ParseError | typeof BetaErrorResponse.Type>;
+    readonly "betaMessageBatchesResults": (messageBatchId: string, options: typeof BetaMessageBatchesResultsParams.Encoded) => Effect.Effect<void, HttpClientError.HttpClientError | ParseError | typeof BetaErrorResponse.Type>;
+    readonly "betaMessagesCountTokensPost": (options: {
+        readonly params: typeof BetaMessagesCountTokensPostParams.Encoded;
+        readonly payload: typeof BetaCountMessageTokensParams.Encoded;
+    }) => Effect.Effect<typeof BetaCountMessageTokensResponse.Type, HttpClientError.HttpClientError | ParseError | typeof BetaErrorResponse.Type>;
+}
+export {};
+//# sourceMappingURL=Generated.d.ts.map