github.com/anthropics/anthropic-sdk-go@v1.70.1/betamessage.go

// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.

package anthropic

import (
	"context"
	"encoding/json"
	"fmt"
	"net/http"
	"slices"
	"time"

	"github.com/anthropics/anthropic-sdk-go/internal/apijson"
	"github.com/anthropics/anthropic-sdk-go/internal/paramutil"
	"github.com/anthropics/anthropic-sdk-go/internal/requestconfig"
	"github.com/anthropics/anthropic-sdk-go/option"
	"github.com/anthropics/anthropic-sdk-go/packages/param"
	"github.com/anthropics/anthropic-sdk-go/packages/respjson"
	"github.com/anthropics/anthropic-sdk-go/packages/ssestream"
	"github.com/anthropics/anthropic-sdk-go/shared/constant"
)

// BetaMessageService contains methods and other services that help with
// interacting with the anthropic API.
//
// Note, unlike clients, this service does not read variables from the environment
// automatically. You should not instantiate this service directly, and instead use
// the [NewBetaMessageService] method instead.
type BetaMessageService struct {
	Options []option.RequestOption
	Batches BetaMessageBatchService
}

// NewBetaMessageService generates a new service that applies the given options to
// each request. These options are applied after the parent client's options (if
// there is one), and before any request-specific options.
func NewBetaMessageService(opts ...option.RequestOption) (r BetaMessageService) {
	r = BetaMessageService{}
	r.Options = opts
	r.Batches = NewBetaMessageBatchService(opts...)
	return
}

// Send a structured list of input messages with text and/or image content, and the
// model will generate the next message in the conversation.
//
// The Messages API can be used for either single queries or stateless multi-turn
// conversations.
//
// Learn more about the Messages API in our
// [user guide](https://platform.claude.com/docs/en/get-started)
//
// Note: If you choose to set a timeout for this request, we recommend 10 minutes.
func (r *BetaMessageService) New(ctx context.Context, params BetaMessageNewParams, opts ...option.RequestOption) (res *BetaMessage, err error) {
	for _, v := range params.Betas {
		opts = append(opts, option.WithHeaderAdd("anthropic-beta", fmt.Sprintf("%v", v)))
	}
	if !param.IsOmitted(params.UserProfileID) {
		opts = append(opts, option.WithHeader("anthropic-user-profile-id", fmt.Sprintf("%v", params.UserProfileID.Value)))
	}
	if !param.IsOmitted(params.WorkspaceID) {
		opts = append(opts, option.WithHeader("anthropic-workspace-id", fmt.Sprintf("%v", params.WorkspaceID.Value)))
	}
	opts = slices.Concat(r.Options, opts)
	warnIfThinkingEnabled(params.Model, params.Thinking.OfEnabled != nil)

	// For non-streaming requests, calculate the appropriate timeout based on maxTokens
	// and check against model-specific limits
	timeout, timeoutErr := CalculateNonStreamingTimeout(int(params.MaxTokens), params.Model, opts)
	if timeoutErr != nil {
		return nil, timeoutErr
	}
	opts = append(opts, option.WithRequestTimeout(timeout))

	path := "v1/messages?beta=true"
	err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, params, &res, opts...)
	if err != nil {
		return nil, err
	}
	if dest, ok := outputFormatDest(params); ok {
		if parseErr := parseOutputContent(res, dest); parseErr != nil {
			return res, parseErr
		}
	}
	return res, err
}

// Send a structured list of input messages with text and/or image content, and the
// model will generate the next message in the conversation.
//
// The Messages API can be used for either single queries or stateless multi-turn
// conversations.
//
// Learn more about the Messages API in our
// [user guide](https://platform.claude.com/docs/en/get-started)
//
// Note: If you choose to set a timeout for this request, we recommend 10 minutes.
func (r *BetaMessageService) NewStreaming(ctx context.Context, params BetaMessageNewParams, opts ...option.RequestOption) (stream *ssestream.Stream[BetaRawMessageStreamEventUnion]) {
	var (
		raw *http.Response
		err error
	)
	for _, v := range params.Betas {
		opts = append(opts, option.WithHeaderAdd("anthropic-beta", fmt.Sprintf("%v", v)))
	}
	if !param.IsOmitted(params.UserProfileID) {
		opts = append(opts, option.WithHeader("anthropic-user-profile-id", fmt.Sprintf("%v", params.UserProfileID.Value)))
	}
	if !param.IsOmitted(params.WorkspaceID) {
		opts = append(opts, option.WithHeader("anthropic-workspace-id", fmt.Sprintf("%v", params.WorkspaceID.Value)))
	}
	opts = slices.Concat(r.Options, opts)
	warnIfThinkingEnabled(params.Model, params.Thinking.OfEnabled != nil)
	opts = append(opts, option.WithJSONSet("stream", true))
	path := "v1/messages?beta=true"
	err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, params, &raw, opts...)
	return ssestream.NewStream[BetaRawMessageStreamEventUnion](ssestream.NewDecoder(raw), err)
}

// Count the number of tokens in a Message.
//
// The Token Count API can be used to count the number of tokens in a Message,
// including tools, images, and documents, without creating it.
//
// Learn more about token counting in our
// [user guide](https://platform.claude.com/docs/en/build-with-claude/token-counting)
func (r *BetaMessageService) CountTokens(ctx context.Context, params BetaMessageCountTokensParams, opts ...option.RequestOption) (res *BetaMessageTokensCount, err error) {
	for _, v := range params.Betas {
		opts = append(opts, option.WithHeaderAdd("anthropic-beta", fmt.Sprintf("%v", v)))
	}
	if !param.IsOmitted(params.UserProfileID) {
		opts = append(opts, option.WithHeader("anthropic-user-profile-id", fmt.Sprintf("%v", params.UserProfileID.Value)))
	}
	if !param.IsOmitted(params.WorkspaceID) {
		opts = append(opts, option.WithHeader("anthropic-workspace-id", fmt.Sprintf("%v", params.WorkspaceID.Value)))
	}
	opts = slices.Concat(r.Options, opts)
	path := "v1/messages/count_tokens?beta=true"
	err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, params, &res, opts...)
	return res, err
}

// Token usage for an advisor sub-inference iteration.
type BetaAdvisorMessageIterationUsage struct {
	// Breakdown of cached tokens by TTL
	CacheCreation BetaCacheCreation `json:"cache_creation" api:"required"`
	// The number of input tokens used to create the cache entry.
	CacheCreationInputTokens int64 `json:"cache_creation_input_tokens" api:"required"`
	// The number of input tokens read from the cache.
	CacheReadInputTokens int64 `json:"cache_read_input_tokens" api:"required"`
	// The number of input tokens which were used.
	InputTokens int64 `json:"input_tokens" api:"required"`
	// The model that will complete your prompt.
	//
	// See [models](https://docs.anthropic.com/en/docs/models-overview) for additional
	// details and options.
	Model Model `json:"model" api:"required"`
	// The number of output tokens which were used.
	OutputTokens int64 `json:"output_tokens" api:"required"`
	// Usage for an advisor sub-inference iteration
	Type constant.AdvisorMessage `json:"type" default:"advisor_message"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CacheCreation            respjson.Field
		CacheCreationInputTokens respjson.Field
		CacheReadInputTokens     respjson.Field
		InputTokens              respjson.Field
		Model                    respjson.Field
		OutputTokens             respjson.Field
		Type                     respjson.Field
		ExtraFields              map[string]respjson.Field
		raw                      string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaAdvisorMessageIterationUsage) RawJSON() string { return r.JSON.raw }
func (r *BetaAdvisorMessageIterationUsage) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaAdvisorRedactedResultBlock struct {
	// Opaque blob containing the advisor's output. Round-trip verbatim; do not inspect
	// or modify.
	EncryptedContent string `json:"encrypted_content" api:"required"`
	// The advisor sub-inference's stop reason (same values as the top-level message
	// `stop_reason`).
	StopReason string                         `json:"stop_reason" api:"required"`
	Type       constant.AdvisorRedactedResult `json:"type" default:"advisor_redacted_result"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		EncryptedContent respjson.Field
		StopReason       respjson.Field
		Type             respjson.Field
		ExtraFields      map[string]respjson.Field
		raw              string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaAdvisorRedactedResultBlock) RawJSON() string { return r.JSON.raw }
func (r *BetaAdvisorRedactedResultBlock) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties EncryptedContent, Type are required.
type BetaAdvisorRedactedResultBlockParam struct {
	// Opaque blob produced by a prior response; must be round-tripped verbatim.
	EncryptedContent string            `json:"encrypted_content" api:"required"`
	StopReason       param.Opt[string] `json:"stop_reason,omitzero"`
	// This field can be elided, and will marshal its zero value as
	// "advisor_redacted_result".
	Type constant.AdvisorRedactedResult `json:"type" default:"advisor_redacted_result"`
	paramObj
}

func (r BetaAdvisorRedactedResultBlockParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaAdvisorRedactedResultBlockParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaAdvisorRedactedResultBlockParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaAdvisorResultBlock struct {
	// The advisor sub-inference's stop reason (same values as the top-level message
	// `stop_reason`). `max_tokens` indicates the advisor's output was truncated at the
	// tool's `max_tokens` value or the advisor model's policy cap.
	StopReason string                 `json:"stop_reason" api:"required"`
	Text       string                 `json:"text" api:"required"`
	Type       constant.AdvisorResult `json:"type" default:"advisor_result"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		StopReason  respjson.Field
		Text        respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaAdvisorResultBlock) RawJSON() string { return r.JSON.raw }
func (r *BetaAdvisorResultBlock) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties Text, Type are required.
type BetaAdvisorResultBlockParam struct {
	Text       string            `json:"text" api:"required"`
	StopReason param.Opt[string] `json:"stop_reason,omitzero"`
	// This field can be elided, and will marshal its zero value as "advisor_result".
	Type constant.AdvisorResult `json:"type" default:"advisor_result"`
	paramObj
}

func (r BetaAdvisorResultBlockParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaAdvisorResultBlockParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaAdvisorResultBlockParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties Model, Name, Type are required.
type BetaAdvisorTool20260301Param struct {
	// The model that will complete your prompt.
	//
	// See [models](https://docs.anthropic.com/en/docs/models-overview) for additional
	// details and options.
	Model Model `json:"model,omitzero" api:"required"`
	// Bounds the advisor's total output (thinking + text) per call. When the advisor
	// hits this cap, the returned advisor_result or advisor_redacted_result block
	// carries stop_reason='max_tokens', and a truncation note is appended to the
	// advice text the worker model sees (inside the encrypted blob in redacted mode).
	// When set, the server also emits a remaining-tokens budget block in the advisor's
	// prompt so the advisor self-shapes toward the cap. When omitted, the advisor
	// model's default output cap applies and no budget block is emitted.
	MaxTokens param.Opt[int64] `json:"max_tokens,omitzero"`
	// Maximum number of times the tool can be used in the API request.
	MaxUses param.Opt[int64] `json:"max_uses,omitzero"`
	// If true, tool will not be included in initial system prompt. Only loaded when
	// returned via tool_reference from tool search.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// When true, guarantees schema validation on tool names and inputs
	Strict param.Opt[bool] `json:"strict,omitzero"`
	// Any of "direct", "code_execution_20250825", "code_execution_20260120",
	// "code_execution_20260521".
	AllowedCallers []string `json:"allowed_callers,omitzero"`
	// Create a cache control breakpoint at this content block.
	CacheControl BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	// Caching for the advisor's own prompt. When set, each advisor call writes a cache
	// entry at the given TTL so subsequent calls in the same conversation read the
	// stable prefix. When omitted, the advisor prompt is not cached.
	Caching BetaCacheControlEphemeralParam `json:"caching,omitzero"`
	// Name of the tool.
	//
	// This is how the tool will be called by the model and in `tool_use` blocks.
	//
	// This field can be elided, and will marshal its zero value as "advisor".
	Name constant.Advisor `json:"name" default:"advisor"`
	// This field can be elided, and will marshal its zero value as "advisor_20260301".
	Type constant.Advisor20260301 `json:"type" default:"advisor_20260301"`
	paramObj
}

func (r BetaAdvisorTool20260301Param) MarshalJSON() (data []byte, err error) {
	type shadow BetaAdvisorTool20260301Param
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaAdvisorTool20260301Param) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaAdvisorToolResultBlock struct {
	Content   BetaAdvisorToolResultBlockContentUnion `json:"content" api:"required"`
	ToolUseID string                                 `json:"tool_use_id" api:"required"`
	Type      constant.AdvisorToolResult             `json:"type" default:"advisor_tool_result"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Content     respjson.Field
		ToolUseID   respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaAdvisorToolResultBlock) RawJSON() string { return r.JSON.raw }
func (r *BetaAdvisorToolResultBlock) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// BetaAdvisorToolResultBlockContentUnion contains all possible properties and
// values from [BetaAdvisorToolResultError], [BetaAdvisorResultBlock],
// [BetaAdvisorRedactedResultBlock].
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
type BetaAdvisorToolResultBlockContentUnion struct {
	// This field is from variant [BetaAdvisorToolResultError].
	ErrorCode  BetaAdvisorToolResultErrorErrorCode `json:"error_code"`
	Type       string                              `json:"type"`
	StopReason string                              `json:"stop_reason"`
	// This field is from variant [BetaAdvisorResultBlock].
	Text string `json:"text"`
	// This field is from variant [BetaAdvisorRedactedResultBlock].
	EncryptedContent string `json:"encrypted_content"`
	JSON             struct {
		ErrorCode        respjson.Field
		Type             respjson.Field
		StopReason       respjson.Field
		Text             respjson.Field
		EncryptedContent respjson.Field
		raw              string
	} `json:"-"`
}

func (u BetaAdvisorToolResultBlockContentUnion) AsResponseAdvisorToolResultError() (v BetaAdvisorToolResultError) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaAdvisorToolResultBlockContentUnion) AsResponseAdvisorResultBlock() (v BetaAdvisorResultBlock) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaAdvisorToolResultBlockContentUnion) AsResponseAdvisorRedactedResultBlock() (v BetaAdvisorRedactedResultBlock) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u BetaAdvisorToolResultBlockContentUnion) RawJSON() string { return u.JSON.raw }

func (r *BetaAdvisorToolResultBlockContentUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties Content, ToolUseID, Type are required.
type BetaAdvisorToolResultBlockParam struct {
	Content   BetaAdvisorToolResultBlockParamContentUnion `json:"content,omitzero" api:"required"`
	ToolUseID string                                      `json:"tool_use_id" api:"required"`
	// Create a cache control breakpoint at this content block.
	CacheControl BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	// This field can be elided, and will marshal its zero value as
	// "advisor_tool_result".
	Type constant.AdvisorToolResult `json:"type" default:"advisor_tool_result"`
	paramObj
}

func (r BetaAdvisorToolResultBlockParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaAdvisorToolResultBlockParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaAdvisorToolResultBlockParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Only one field can be non-zero.
//
// Use [param.IsOmitted] to confirm if a field is set.
type BetaAdvisorToolResultBlockParamContentUnion struct {
	OfRequestAdvisorToolResultError     *BetaAdvisorToolResultErrorParam     `json:",omitzero,inline"`
	OfRequestAdvisorResultBlock         *BetaAdvisorResultBlockParam         `json:",omitzero,inline"`
	OfRequestAdvisorRedactedResultBlock *BetaAdvisorRedactedResultBlockParam `json:",omitzero,inline"`
	paramUnion
}

func (u BetaAdvisorToolResultBlockParamContentUnion) MarshalJSON() ([]byte, error) {
	return param.MarshalUnion(u, u.OfRequestAdvisorToolResultError, u.OfRequestAdvisorResultBlock, u.OfRequestAdvisorRedactedResultBlock)
}
func (u *BetaAdvisorToolResultBlockParamContentUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, u)
}

func (u *BetaAdvisorToolResultBlockParamContentUnion) asAny() any {
	if !param.IsOmitted(u.OfRequestAdvisorToolResultError) {
		return u.OfRequestAdvisorToolResultError
	} else if !param.IsOmitted(u.OfRequestAdvisorResultBlock) {
		return u.OfRequestAdvisorResultBlock
	} else if !param.IsOmitted(u.OfRequestAdvisorRedactedResultBlock) {
		return u.OfRequestAdvisorRedactedResultBlock
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaAdvisorToolResultBlockParamContentUnion) GetErrorCode() *string {
	if vt := u.OfRequestAdvisorToolResultError; vt != nil {
		return (*string)(&vt.ErrorCode)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaAdvisorToolResultBlockParamContentUnion) GetText() *string {
	if vt := u.OfRequestAdvisorResultBlock; vt != nil {
		return &vt.Text
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaAdvisorToolResultBlockParamContentUnion) GetEncryptedContent() *string {
	if vt := u.OfRequestAdvisorRedactedResultBlock; vt != nil {
		return &vt.EncryptedContent
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaAdvisorToolResultBlockParamContentUnion) GetType() *string {
	if vt := u.OfRequestAdvisorToolResultError; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfRequestAdvisorResultBlock; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfRequestAdvisorRedactedResultBlock; vt != nil {
		return (*string)(&vt.Type)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaAdvisorToolResultBlockParamContentUnion) GetStopReason() *string {
	if vt := u.OfRequestAdvisorResultBlock; vt != nil && vt.StopReason.Valid() {
		return &vt.StopReason.Value
	} else if vt := u.OfRequestAdvisorRedactedResultBlock; vt != nil && vt.StopReason.Valid() {
		return &vt.StopReason.Value
	}
	return nil
}

type BetaAdvisorToolResultError struct {
	// Any of "max_uses_exceeded", "prompt_too_long", "too_many_requests",
	// "overloaded", "unavailable", "execution_time_exceeded", "model_not_found".
	ErrorCode BetaAdvisorToolResultErrorErrorCode `json:"error_code" api:"required"`
	Type      constant.AdvisorToolResultError     `json:"type" default:"advisor_tool_result_error"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ErrorCode   respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaAdvisorToolResultError) RawJSON() string { return r.JSON.raw }
func (r *BetaAdvisorToolResultError) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaAdvisorToolResultErrorErrorCode string

const (
	BetaAdvisorToolResultErrorErrorCodeMaxUsesExceeded       BetaAdvisorToolResultErrorErrorCode = "max_uses_exceeded"
	BetaAdvisorToolResultErrorErrorCodePromptTooLong         BetaAdvisorToolResultErrorErrorCode = "prompt_too_long"
	BetaAdvisorToolResultErrorErrorCodeTooManyRequests       BetaAdvisorToolResultErrorErrorCode = "too_many_requests"
	BetaAdvisorToolResultErrorErrorCodeOverloaded            BetaAdvisorToolResultErrorErrorCode = "overloaded"
	BetaAdvisorToolResultErrorErrorCodeUnavailable           BetaAdvisorToolResultErrorErrorCode = "unavailable"
	BetaAdvisorToolResultErrorErrorCodeExecutionTimeExceeded BetaAdvisorToolResultErrorErrorCode = "execution_time_exceeded"
	BetaAdvisorToolResultErrorErrorCodeModelNotFound         BetaAdvisorToolResultErrorErrorCode = "model_not_found"
)

// The properties ErrorCode, Type are required.
type BetaAdvisorToolResultErrorParam struct {
	// Any of "max_uses_exceeded", "prompt_too_long", "too_many_requests",
	// "overloaded", "unavailable", "execution_time_exceeded", "model_not_found".
	ErrorCode BetaAdvisorToolResultErrorParamErrorCode `json:"error_code,omitzero" api:"required"`
	// This field can be elided, and will marshal its zero value as
	// "advisor_tool_result_error".
	Type constant.AdvisorToolResultError `json:"type" default:"advisor_tool_result_error"`
	paramObj
}

func (r BetaAdvisorToolResultErrorParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaAdvisorToolResultErrorParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaAdvisorToolResultErrorParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaAdvisorToolResultErrorParamErrorCode string

const (
	BetaAdvisorToolResultErrorParamErrorCodeMaxUsesExceeded       BetaAdvisorToolResultErrorParamErrorCode = "max_uses_exceeded"
	BetaAdvisorToolResultErrorParamErrorCodePromptTooLong         BetaAdvisorToolResultErrorParamErrorCode = "prompt_too_long"
	BetaAdvisorToolResultErrorParamErrorCodeTooManyRequests       BetaAdvisorToolResultErrorParamErrorCode = "too_many_requests"
	BetaAdvisorToolResultErrorParamErrorCodeOverloaded            BetaAdvisorToolResultErrorParamErrorCode = "overloaded"
	BetaAdvisorToolResultErrorParamErrorCodeUnavailable           BetaAdvisorToolResultErrorParamErrorCode = "unavailable"
	BetaAdvisorToolResultErrorParamErrorCodeExecutionTimeExceeded BetaAdvisorToolResultErrorParamErrorCode = "execution_time_exceeded"
	BetaAdvisorToolResultErrorParamErrorCodeModelNotFound         BetaAdvisorToolResultErrorParamErrorCode = "model_not_found"
)

func NewBetaAllThinkingTurnsParam() BetaAllThinkingTurnsParam {
	return BetaAllThinkingTurnsParam{
		Type: "all",
	}
}

// This struct has a constant value, construct it with
// [NewBetaAllThinkingTurnsParam].
type BetaAllThinkingTurnsParam struct {
	Type constant.All `json:"type" default:"all"`
	paramObj
}

func (r BetaAllThinkingTurnsParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaAllThinkingTurnsParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaAllThinkingTurnsParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties Data, MediaType, Type are required.
type BetaBase64ImageSourceParam struct {
	Data string `json:"data" api:"required" format:"byte"`
	// Any of "image/jpeg", "image/png", "image/gif", "image/webp".
	MediaType BetaBase64ImageSourceMediaType `json:"media_type,omitzero" api:"required"`
	// This field can be elided, and will marshal its zero value as "base64".
	Type constant.Base64 `json:"type" default:"base64"`
	paramObj
}

func (r BetaBase64ImageSourceParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaBase64ImageSourceParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaBase64ImageSourceParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaBase64ImageSourceMediaType string

const (
	BetaBase64ImageSourceMediaTypeImageJPEG BetaBase64ImageSourceMediaType = "image/jpeg"
	BetaBase64ImageSourceMediaTypeImagePNG  BetaBase64ImageSourceMediaType = "image/png"
	BetaBase64ImageSourceMediaTypeImageGIF  BetaBase64ImageSourceMediaType = "image/gif"
	BetaBase64ImageSourceMediaTypeImageWebP BetaBase64ImageSourceMediaType = "image/webp"
)

type BetaBase64PDFSource struct {
	Data      string                  `json:"data" api:"required" format:"byte"`
	MediaType constant.ApplicationPDF `json:"media_type" default:"application/pdf"`
	Type      constant.Base64         `json:"type" default:"base64"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Data        respjson.Field
		MediaType   respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaBase64PDFSource) RawJSON() string { return r.JSON.raw }
func (r *BetaBase64PDFSource) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// ToParam converts this BetaBase64PDFSource to a BetaBase64PDFSourceParam.
//
// Warning: the fields of the param type will not be present. ToParam should only
// be used at the last possible moment before sending a request. Test for this with
// BetaBase64PDFSourceParam.Overrides()
func (r BetaBase64PDFSource) ToParam() BetaBase64PDFSourceParam {
	return param.Override[BetaBase64PDFSourceParam](json.RawMessage(r.RawJSON()))
}

// The properties Data, MediaType, Type are required.
type BetaBase64PDFSourceParam struct {
	Data string `json:"data" api:"required" format:"byte"`
	// This field can be elided, and will marshal its zero value as "application/pdf".
	MediaType constant.ApplicationPDF `json:"media_type" default:"application/pdf"`
	// This field can be elided, and will marshal its zero value as "base64".
	Type constant.Base64 `json:"type" default:"base64"`
	paramObj
}

func (r BetaBase64PDFSourceParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaBase64PDFSourceParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaBase64PDFSourceParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaBashCodeExecutionOutputBlock struct {
	FileID string                           `json:"file_id" api:"required"`
	Type   constant.BashCodeExecutionOutput `json:"type" default:"bash_code_execution_output"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		FileID      respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaBashCodeExecutionOutputBlock) RawJSON() string { return r.JSON.raw }
func (r *BetaBashCodeExecutionOutputBlock) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties FileID, Type are required.
type BetaBashCodeExecutionOutputBlockParam struct {
	FileID string `json:"file_id" api:"required"`
	// This field can be elided, and will marshal its zero value as
	// "bash_code_execution_output".
	Type constant.BashCodeExecutionOutput `json:"type" default:"bash_code_execution_output"`
	paramObj
}

func (r BetaBashCodeExecutionOutputBlockParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaBashCodeExecutionOutputBlockParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaBashCodeExecutionOutputBlockParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaBashCodeExecutionResultBlock struct {
	Content    []BetaBashCodeExecutionOutputBlock `json:"content" api:"required"`
	ReturnCode int64                              `json:"return_code" api:"required"`
	Stderr     string                             `json:"stderr" api:"required"`
	Stdout     string                             `json:"stdout" api:"required"`
	Type       constant.BashCodeExecutionResult   `json:"type" default:"bash_code_execution_result"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Content     respjson.Field
		ReturnCode  respjson.Field
		Stderr      respjson.Field
		Stdout      respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaBashCodeExecutionResultBlock) RawJSON() string { return r.JSON.raw }
func (r *BetaBashCodeExecutionResultBlock) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties Content, ReturnCode, Stderr, Stdout, Type are required.
type BetaBashCodeExecutionResultBlockParam struct {
	Content    []BetaBashCodeExecutionOutputBlockParam `json:"content,omitzero" api:"required"`
	ReturnCode int64                                   `json:"return_code" api:"required"`
	Stderr     string                                  `json:"stderr" api:"required"`
	Stdout     string                                  `json:"stdout" api:"required"`
	// This field can be elided, and will marshal its zero value as
	// "bash_code_execution_result".
	Type constant.BashCodeExecutionResult `json:"type" default:"bash_code_execution_result"`
	paramObj
}

func (r BetaBashCodeExecutionResultBlockParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaBashCodeExecutionResultBlockParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaBashCodeExecutionResultBlockParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaBashCodeExecutionToolResultBlock struct {
	Content   BetaBashCodeExecutionToolResultBlockContentUnion `json:"content" api:"required"`
	ToolUseID string                                           `json:"tool_use_id" api:"required"`
	Type      constant.BashCodeExecutionToolResult             `json:"type" default:"bash_code_execution_tool_result"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Content     respjson.Field
		ToolUseID   respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaBashCodeExecutionToolResultBlock) RawJSON() string { return r.JSON.raw }
func (r *BetaBashCodeExecutionToolResultBlock) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// BetaBashCodeExecutionToolResultBlockContentUnion contains all possible
// properties and values from [BetaBashCodeExecutionToolResultError],
// [BetaBashCodeExecutionResultBlock].
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
type BetaBashCodeExecutionToolResultBlockContentUnion struct {
	// This field is from variant [BetaBashCodeExecutionToolResultError].
	ErrorCode BetaBashCodeExecutionToolResultErrorErrorCode `json:"error_code"`
	Type      string                                        `json:"type"`
	// This field is from variant [BetaBashCodeExecutionResultBlock].
	Content []BetaBashCodeExecutionOutputBlock `json:"content"`
	// This field is from variant [BetaBashCodeExecutionResultBlock].
	ReturnCode int64 `json:"return_code"`
	// This field is from variant [BetaBashCodeExecutionResultBlock].
	Stderr string `json:"stderr"`
	// This field is from variant [BetaBashCodeExecutionResultBlock].
	Stdout string `json:"stdout"`
	JSON   struct {
		ErrorCode  respjson.Field
		Type       respjson.Field
		Content    respjson.Field
		ReturnCode respjson.Field
		Stderr     respjson.Field
		Stdout     respjson.Field
		raw        string
	} `json:"-"`
}

func (u BetaBashCodeExecutionToolResultBlockContentUnion) AsResponseBashCodeExecutionToolResultError() (v BetaBashCodeExecutionToolResultError) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaBashCodeExecutionToolResultBlockContentUnion) AsResponseBashCodeExecutionResultBlock() (v BetaBashCodeExecutionResultBlock) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u BetaBashCodeExecutionToolResultBlockContentUnion) RawJSON() string { return u.JSON.raw }

func (r *BetaBashCodeExecutionToolResultBlockContentUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties Content, ToolUseID, Type are required.
type BetaBashCodeExecutionToolResultBlockParam struct {
	Content   BetaBashCodeExecutionToolResultBlockParamContentUnion `json:"content,omitzero" api:"required"`
	ToolUseID string                                                `json:"tool_use_id" api:"required"`
	// Create a cache control breakpoint at this content block.
	CacheControl BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	// This field can be elided, and will marshal its zero value as
	// "bash_code_execution_tool_result".
	Type constant.BashCodeExecutionToolResult `json:"type" default:"bash_code_execution_tool_result"`
	paramObj
}

func (r BetaBashCodeExecutionToolResultBlockParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaBashCodeExecutionToolResultBlockParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaBashCodeExecutionToolResultBlockParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Only one field can be non-zero.
//
// Use [param.IsOmitted] to confirm if a field is set.
type BetaBashCodeExecutionToolResultBlockParamContentUnion struct {
	OfRequestBashCodeExecutionToolResultError *BetaBashCodeExecutionToolResultErrorParam `json:",omitzero,inline"`
	OfRequestBashCodeExecutionResultBlock     *BetaBashCodeExecutionResultBlockParam     `json:",omitzero,inline"`
	paramUnion
}

func (u BetaBashCodeExecutionToolResultBlockParamContentUnion) MarshalJSON() ([]byte, error) {
	return param.MarshalUnion(u, u.OfRequestBashCodeExecutionToolResultError, u.OfRequestBashCodeExecutionResultBlock)
}
func (u *BetaBashCodeExecutionToolResultBlockParamContentUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, u)
}

func (u *BetaBashCodeExecutionToolResultBlockParamContentUnion) asAny() any {
	if !param.IsOmitted(u.OfRequestBashCodeExecutionToolResultError) {
		return u.OfRequestBashCodeExecutionToolResultError
	} else if !param.IsOmitted(u.OfRequestBashCodeExecutionResultBlock) {
		return u.OfRequestBashCodeExecutionResultBlock
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaBashCodeExecutionToolResultBlockParamContentUnion) GetErrorCode() *string {
	if vt := u.OfRequestBashCodeExecutionToolResultError; vt != nil {
		return (*string)(&vt.ErrorCode)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaBashCodeExecutionToolResultBlockParamContentUnion) GetContent() []BetaBashCodeExecutionOutputBlockParam {
	if vt := u.OfRequestBashCodeExecutionResultBlock; vt != nil {
		return vt.Content
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaBashCodeExecutionToolResultBlockParamContentUnion) GetReturnCode() *int64 {
	if vt := u.OfRequestBashCodeExecutionResultBlock; vt != nil {
		return &vt.ReturnCode
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaBashCodeExecutionToolResultBlockParamContentUnion) GetStderr() *string {
	if vt := u.OfRequestBashCodeExecutionResultBlock; vt != nil {
		return &vt.Stderr
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaBashCodeExecutionToolResultBlockParamContentUnion) GetStdout() *string {
	if vt := u.OfRequestBashCodeExecutionResultBlock; vt != nil {
		return &vt.Stdout
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaBashCodeExecutionToolResultBlockParamContentUnion) GetType() *string {
	if vt := u.OfRequestBashCodeExecutionToolResultError; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfRequestBashCodeExecutionResultBlock; vt != nil {
		return (*string)(&vt.Type)
	}
	return nil
}

type BetaBashCodeExecutionToolResultError struct {
	// Any of "invalid_tool_input", "unavailable", "too_many_requests",
	// "execution_time_exceeded", "output_file_too_large".
	ErrorCode BetaBashCodeExecutionToolResultErrorErrorCode `json:"error_code" api:"required"`
	Type      constant.BashCodeExecutionToolResultError     `json:"type" default:"bash_code_execution_tool_result_error"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ErrorCode   respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaBashCodeExecutionToolResultError) RawJSON() string { return r.JSON.raw }
func (r *BetaBashCodeExecutionToolResultError) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaBashCodeExecutionToolResultErrorErrorCode string

const (
	BetaBashCodeExecutionToolResultErrorErrorCodeInvalidToolInput      BetaBashCodeExecutionToolResultErrorErrorCode = "invalid_tool_input"
	BetaBashCodeExecutionToolResultErrorErrorCodeUnavailable           BetaBashCodeExecutionToolResultErrorErrorCode = "unavailable"
	BetaBashCodeExecutionToolResultErrorErrorCodeTooManyRequests       BetaBashCodeExecutionToolResultErrorErrorCode = "too_many_requests"
	BetaBashCodeExecutionToolResultErrorErrorCodeExecutionTimeExceeded BetaBashCodeExecutionToolResultErrorErrorCode = "execution_time_exceeded"
	BetaBashCodeExecutionToolResultErrorErrorCodeOutputFileTooLarge    BetaBashCodeExecutionToolResultErrorErrorCode = "output_file_too_large"
)

// The properties ErrorCode, Type are required.
type BetaBashCodeExecutionToolResultErrorParam struct {
	// Any of "invalid_tool_input", "unavailable", "too_many_requests",
	// "execution_time_exceeded", "output_file_too_large".
	ErrorCode BetaBashCodeExecutionToolResultErrorParamErrorCode `json:"error_code,omitzero" api:"required"`
	// This field can be elided, and will marshal its zero value as
	// "bash_code_execution_tool_result_error".
	Type constant.BashCodeExecutionToolResultError `json:"type" default:"bash_code_execution_tool_result_error"`
	paramObj
}

func (r BetaBashCodeExecutionToolResultErrorParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaBashCodeExecutionToolResultErrorParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaBashCodeExecutionToolResultErrorParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaBashCodeExecutionToolResultErrorParamErrorCode string

const (
	BetaBashCodeExecutionToolResultErrorParamErrorCodeInvalidToolInput      BetaBashCodeExecutionToolResultErrorParamErrorCode = "invalid_tool_input"
	BetaBashCodeExecutionToolResultErrorParamErrorCodeUnavailable           BetaBashCodeExecutionToolResultErrorParamErrorCode = "unavailable"
	BetaBashCodeExecutionToolResultErrorParamErrorCodeTooManyRequests       BetaBashCodeExecutionToolResultErrorParamErrorCode = "too_many_requests"
	BetaBashCodeExecutionToolResultErrorParamErrorCodeExecutionTimeExceeded BetaBashCodeExecutionToolResultErrorParamErrorCode = "execution_time_exceeded"
	BetaBashCodeExecutionToolResultErrorParamErrorCodeOutputFileTooLarge    BetaBashCodeExecutionToolResultErrorParamErrorCode = "output_file_too_large"
)

// `close_tab`'s config overrides.
type BetaBrowserCloseTabConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaBrowserCloseTabConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaBrowserCloseTabConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaBrowserCloseTabConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `double_click`'s config overrides.
type BetaBrowserDoubleClickConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaBrowserDoubleClickConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaBrowserDoubleClickConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaBrowserDoubleClickConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `file_upload`'s config overrides.
type BetaBrowserFileUploadConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaBrowserFileUploadConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaBrowserFileUploadConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaBrowserFileUploadConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `find`'s config overrides.
type BetaBrowserFindConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaBrowserFindConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaBrowserFindConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaBrowserFindConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `form_input`'s config overrides.
type BetaBrowserFormInputConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaBrowserFormInputConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaBrowserFormInputConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaBrowserFormInputConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `get_page_text`'s config overrides.
type BetaBrowserGetPageTextConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaBrowserGetPageTextConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaBrowserGetPageTextConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaBrowserGetPageTextConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `hold_key`'s config overrides.
type BetaBrowserHoldKeyConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaBrowserHoldKeyConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaBrowserHoldKeyConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaBrowserHoldKeyConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `hover`'s config overrides.
type BetaBrowserHoverConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaBrowserHoverConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaBrowserHoverConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaBrowserHoverConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `javascript_exec`'s config overrides.
type BetaBrowserJavascriptExecConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaBrowserJavascriptExecConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaBrowserJavascriptExecConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaBrowserJavascriptExecConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `key`'s config overrides.
type BetaBrowserKeyConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaBrowserKeyConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaBrowserKeyConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaBrowserKeyConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `left_click`'s config overrides.
type BetaBrowserLeftClickConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaBrowserLeftClickConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaBrowserLeftClickConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaBrowserLeftClickConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `left_click_drag`'s config overrides.
type BetaBrowserLeftClickDragConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaBrowserLeftClickDragConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaBrowserLeftClickDragConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaBrowserLeftClickDragConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `left_mouse_down`'s config overrides.
type BetaBrowserLeftMouseDownConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaBrowserLeftMouseDownConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaBrowserLeftMouseDownConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaBrowserLeftMouseDownConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `left_mouse_up`'s config overrides.
type BetaBrowserLeftMouseUpConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaBrowserLeftMouseUpConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaBrowserLeftMouseUpConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaBrowserLeftMouseUpConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `list_tabs`'s config overrides.
type BetaBrowserListTabsConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaBrowserListTabsConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaBrowserListTabsConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaBrowserListTabsConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `middle_click`'s config overrides.
type BetaBrowserMiddleClickConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaBrowserMiddleClickConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaBrowserMiddleClickConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaBrowserMiddleClickConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `mouse_move`'s config overrides.
type BetaBrowserMouseMoveConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaBrowserMouseMoveConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaBrowserMouseMoveConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaBrowserMouseMoveConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `navigate`'s config overrides.
type BetaBrowserNavigateConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaBrowserNavigateConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaBrowserNavigateConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaBrowserNavigateConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `new_tab`'s config overrides.
type BetaBrowserNewTabConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaBrowserNewTabConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaBrowserNewTabConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaBrowserNewTabConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `read_console`'s config overrides.
type BetaBrowserReadConsoleConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaBrowserReadConsoleConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaBrowserReadConsoleConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaBrowserReadConsoleConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `read_network`'s config overrides.
type BetaBrowserReadNetworkConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaBrowserReadNetworkConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaBrowserReadNetworkConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaBrowserReadNetworkConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `read_page`'s config overrides.
type BetaBrowserReadPageConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaBrowserReadPageConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaBrowserReadPageConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaBrowserReadPageConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `right_click`'s config overrides.
type BetaBrowserRightClickConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaBrowserRightClickConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaBrowserRightClickConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaBrowserRightClickConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `screenshot`'s config overrides.
type BetaBrowserScreenshotConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaBrowserScreenshotConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaBrowserScreenshotConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaBrowserScreenshotConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `scroll`'s config overrides.
type BetaBrowserScrollConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaBrowserScrollConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaBrowserScrollConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaBrowserScrollConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `scroll_to`'s config overrides.
type BetaBrowserScrollToConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaBrowserScrollToConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaBrowserScrollToConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaBrowserScrollToConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The caller's browser state after a browser toolset member call — the full
// inventory of open tabs, which tab is active, and any side effects (tabs opened,
// download state changes) the call produced.
//
// At most one per `tool_result`, only on a non-error result answering a browser
// toolset member `tool_use`. The server renders the model-visible text from it;
// the model never sees the raw fields.
//
// The properties Tabs, Type are required.
type BetaBrowserStateBlockParam struct {
	// All tabs open in the browser after this call — the full inventory, not a delta.
	// May be empty. Whenever non-empty, exactly one entry carries `active: true`.
	Tabs []BetaBrowserStateTabEntryParam `json:"tabs,omitzero" api:"required"`
	// Tabs opened and download state changes during this call. "Nothing to report" is
	// expressed by omitting the field, never by an empty list.
	StateChanges []BetaBrowserStateChangeUnionParam `json:"state_changes,omitzero"`
	// Create a cache control breakpoint at this content block.
	CacheControl BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	// This field can be elided, and will marshal its zero value as "browser_state".
	Type constant.BrowserState `json:"type" default:"browser_state"`
	paramObj
}

func (r BetaBrowserStateBlockParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaBrowserStateBlockParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaBrowserStateBlockParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

func BetaBrowserStateChangeParamOfTabOpened(tabID string) BetaBrowserStateChangeUnionParam {
	var tabOpened BetaBrowserStateChangeTabOpenedParam
	tabOpened.TabID = tabID
	return BetaBrowserStateChangeUnionParam{OfTabOpened: &tabOpened}
}

func BetaBrowserStateChangeParamOfDownloadStarted(downloadID string, url string) BetaBrowserStateChangeUnionParam {
	var downloadStarted BetaBrowserStateChangeDownloadStartedParam
	downloadStarted.DownloadID = downloadID
	downloadStarted.URL = url
	return BetaBrowserStateChangeUnionParam{OfDownloadStarted: &downloadStarted}
}

func BetaBrowserStateChangeParamOfDownloadCompleted(downloadID string, url string) BetaBrowserStateChangeUnionParam {
	var downloadCompleted BetaBrowserStateChangeDownloadCompletedParam
	downloadCompleted.DownloadID = downloadID
	downloadCompleted.URL = url
	return BetaBrowserStateChangeUnionParam{OfDownloadCompleted: &downloadCompleted}
}

func BetaBrowserStateChangeParamOfDownloadFailed(downloadID string, url string) BetaBrowserStateChangeUnionParam {
	var downloadFailed BetaBrowserStateChangeDownloadFailedParam
	downloadFailed.DownloadID = downloadID
	downloadFailed.URL = url
	return BetaBrowserStateChangeUnionParam{OfDownloadFailed: &downloadFailed}
}

// Only one field can be non-zero.
//
// Use [param.IsOmitted] to confirm if a field is set.
type BetaBrowserStateChangeUnionParam struct {
	OfTabOpened         *BetaBrowserStateChangeTabOpenedParam         `json:",omitzero,inline"`
	OfDownloadStarted   *BetaBrowserStateChangeDownloadStartedParam   `json:",omitzero,inline"`
	OfDownloadCompleted *BetaBrowserStateChangeDownloadCompletedParam `json:",omitzero,inline"`
	OfDownloadFailed    *BetaBrowserStateChangeDownloadFailedParam    `json:",omitzero,inline"`
	paramUnion
}

func (u BetaBrowserStateChangeUnionParam) MarshalJSON() ([]byte, error) {
	return param.MarshalUnion(u, u.OfTabOpened, u.OfDownloadStarted, u.OfDownloadCompleted, u.OfDownloadFailed)
}
func (u *BetaBrowserStateChangeUnionParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, u)
}

func (u *BetaBrowserStateChangeUnionParam) asAny() any {
	if !param.IsOmitted(u.OfTabOpened) {
		return u.OfTabOpened
	} else if !param.IsOmitted(u.OfDownloadStarted) {
		return u.OfDownloadStarted
	} else if !param.IsOmitted(u.OfDownloadCompleted) {
		return u.OfDownloadCompleted
	} else if !param.IsOmitted(u.OfDownloadFailed) {
		return u.OfDownloadFailed
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaBrowserStateChangeUnionParam) GetTabID() *string {
	if vt := u.OfTabOpened; vt != nil {
		return &vt.TabID
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaBrowserStateChangeUnionParam) GetPath() *string {
	if vt := u.OfDownloadCompleted; vt != nil && vt.Path.Valid() {
		return &vt.Path.Value
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaBrowserStateChangeUnionParam) GetSizeBytes() *int64 {
	if vt := u.OfDownloadCompleted; vt != nil && vt.SizeBytes.Valid() {
		return &vt.SizeBytes.Value
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaBrowserStateChangeUnionParam) GetError() *string {
	if vt := u.OfDownloadFailed; vt != nil && vt.Error.Valid() {
		return &vt.Error.Value
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaBrowserStateChangeUnionParam) GetType() *string {
	if vt := u.OfTabOpened; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfDownloadStarted; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfDownloadCompleted; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfDownloadFailed; vt != nil {
		return (*string)(&vt.Type)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaBrowserStateChangeUnionParam) GetDownloadID() *string {
	if vt := u.OfDownloadStarted; vt != nil {
		return (*string)(&vt.DownloadID)
	} else if vt := u.OfDownloadCompleted; vt != nil {
		return (*string)(&vt.DownloadID)
	} else if vt := u.OfDownloadFailed; vt != nil {
		return (*string)(&vt.DownloadID)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaBrowserStateChangeUnionParam) GetURL() *string {
	if vt := u.OfDownloadStarted; vt != nil {
		return (*string)(&vt.URL)
	} else if vt := u.OfDownloadCompleted; vt != nil {
		return (*string)(&vt.URL)
	} else if vt := u.OfDownloadFailed; vt != nil {
		return (*string)(&vt.URL)
	}
	return nil
}

func init() {
	apijson.RegisterUnion[BetaBrowserStateChangeUnionParam](
		"type",
		apijson.Discriminator[BetaBrowserStateChangeTabOpenedParam]("tab_opened"),
		apijson.Discriminator[BetaBrowserStateChangeDownloadStartedParam]("download_started"),
		apijson.Discriminator[BetaBrowserStateChangeDownloadCompletedParam]("download_completed"),
		apijson.Discriminator[BetaBrowserStateChangeDownloadFailedParam]("download_failed"),
	)
}

// A file download that finished during this call, reported with the same
// `download_id` as its `download_started` — or without a prior `download_started`,
// when the download finished during the call that started it (at most one state
// change per `download_id` per result).
//
// The properties DownloadID, Type, URL are required.
type BetaBrowserStateChangeDownloadCompletedParam struct {
	// The caller-assigned identifier for this download, stable across the state
	// changes reporting it.
	DownloadID string `json:"download_id" api:"required"`
	// The final post-redirect URL the download was served from.
	URL string `json:"url" api:"required"`
	// Where the executor saved the file, on the executor's filesystem. Only included
	// when another tool in the same environment can read the file at that path.
	Path param.Opt[string] `json:"path,omitzero"`
	// The completed download's size.
	SizeBytes param.Opt[int64] `json:"size_bytes,omitzero"`
	// This field can be elided, and will marshal its zero value as
	// "download_completed".
	Type constant.DownloadCompleted `json:"type" default:"download_completed"`
	paramObj
}

func (r BetaBrowserStateChangeDownloadCompletedParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaBrowserStateChangeDownloadCompletedParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaBrowserStateChangeDownloadCompletedParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// A file download that failed — or was cancelled — during this call.
//
// The properties DownloadID, Type, URL are required.
type BetaBrowserStateChangeDownloadFailedParam struct {
	// The caller-assigned identifier for this download, stable across the state
	// changes reporting it.
	DownloadID string `json:"download_id" api:"required"`
	// The final post-redirect URL the download was served from.
	URL string `json:"url" api:"required"`
	// The failure or cancellation detail, when known.
	Error param.Opt[string] `json:"error,omitzero"`
	// This field can be elided, and will marshal its zero value as "download_failed".
	Type constant.DownloadFailed `json:"type" default:"download_failed"`
	paramObj
}

func (r BetaBrowserStateChangeDownloadFailedParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaBrowserStateChangeDownloadFailedParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaBrowserStateChangeDownloadFailedParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// A file download that started during this call.
//
// The properties DownloadID, Type, URL are required.
type BetaBrowserStateChangeDownloadStartedParam struct {
	// The caller-assigned identifier for this download, stable across the state
	// changes reporting it.
	DownloadID string `json:"download_id" api:"required"`
	// The final post-redirect URL the download was served from.
	URL string `json:"url" api:"required"`
	// This field can be elided, and will marshal its zero value as "download_started".
	Type constant.DownloadStarted `json:"type" default:"download_started"`
	paramObj
}

func (r BetaBrowserStateChangeDownloadStartedParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaBrowserStateChangeDownloadStartedParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaBrowserStateChangeDownloadStartedParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// A tab this call's execution opened that remains open at its end — the creation
// delta of the `tabs` inventory, not an event log.
//
// Carries only the `tab_id`; the tab's `title` and `url` live on its `tabs` entry,
// which must include the same `tab_id`. A tab opened during a failed call gets no
// deferred `tab_opened`; it simply appears in the next result's `tabs` inventory.
//
// The properties TabID, Type are required.
type BetaBrowserStateChangeTabOpenedParam struct {
	// The `tab_id` of the opened tab, present in `tabs`.
	TabID string `json:"tab_id" api:"required"`
	// This field can be elided, and will marshal its zero value as "tab_opened".
	Type constant.TabOpened `json:"type" default:"tab_opened"`
	paramObj
}

func (r BetaBrowserStateChangeTabOpenedParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaBrowserStateChangeTabOpenedParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaBrowserStateChangeTabOpenedParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// One open browser tab reported in a `browser_state` block's `tabs` inventory.
//
// `tab_id` is the caller-assigned identifier for the tab; `title` and `url`
// describe the page the tab is currently showing and may be empty strings (a blank
// tab legitimately has both empty). `active` marks the tab that is active after
// this call; whenever `tabs` is non-empty, exactly one entry is marked.
//
// The properties TabID, Title, URL are required.
type BetaBrowserStateTabEntryParam struct {
	// The caller-assigned identifier for this tab, unique within the inventory.
	TabID string `json:"tab_id" api:"required"`
	// The title of the page the tab is showing. May be empty.
	Title string `json:"title" api:"required"`
	// The URL of the page the tab is showing. May be empty.
	URL string `json:"url" api:"required"`
	// Whether this tab is the active tab after this call. Whenever `tabs` is
	// non-empty, exactly one entry is marked `active: true`.
	Active param.Opt[bool] `json:"active,omitzero"`
	paramObj
}

func (r BetaBrowserStateTabEntryParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaBrowserStateTabEntryParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaBrowserStateTabEntryParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `switch_tab`'s config overrides.
type BetaBrowserSwitchTabConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaBrowserSwitchTabConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaBrowserSwitchTabConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaBrowserSwitchTabConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The browser toolset: a single `tools[]` entry (carrying no `name`) that declares
// the browser tool family. The model is served the family's tool with any members
// disabled via `configs` removed from its schema.
//
// The property Type is required.
type BetaBrowserToolset20260801Param struct {
	// Create a cache control breakpoint at this content block.
	CacheControl BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	// Per-member configuration for `browser_toolset_20260801`: one optional field per
	// member tool, keyed by the member name — the same name the member's `tool_use`
	// blocks carry. Every member is an accepted key, and a member's defaults apply
	// wherever its key is absent. Unknown keys are rejected: the field set is this
	// toolset version's complete member set.
	Configs BetaBrowserToolsetConfigsParam `json:"configs,omitzero"`
	// This field can be elided, and will marshal its zero value as
	// "browser_toolset_20260801".
	Type constant.BrowserToolset20260801 `json:"type" default:"browser_toolset_20260801"`
	paramObj
}

func (r BetaBrowserToolset20260801Param) MarshalJSON() (data []byte, err error) {
	type shadow BetaBrowserToolset20260801Param
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaBrowserToolset20260801Param) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Per-member configuration for `browser_toolset_20260801`: one optional field per
// member tool, keyed by the member name — the same name the member's `tool_use`
// blocks carry. Every member is an accepted key, and a member's defaults apply
// wherever its key is absent. Unknown keys are rejected: the field set is this
// toolset version's complete member set.
type BetaBrowserToolsetConfigsParam struct {
	// `close_tab`'s config overrides.
	CloseTab BetaBrowserCloseTabConfigParam `json:"close_tab,omitzero"`
	// `double_click`'s config overrides.
	DoubleClick BetaBrowserDoubleClickConfigParam `json:"double_click,omitzero"`
	// `file_upload`'s config overrides.
	FileUpload BetaBrowserFileUploadConfigParam `json:"file_upload,omitzero"`
	// `find`'s config overrides.
	Find BetaBrowserFindConfigParam `json:"find,omitzero"`
	// `form_input`'s config overrides.
	FormInput BetaBrowserFormInputConfigParam `json:"form_input,omitzero"`
	// `get_page_text`'s config overrides.
	GetPageText BetaBrowserGetPageTextConfigParam `json:"get_page_text,omitzero"`
	// `hold_key`'s config overrides.
	HoldKey BetaBrowserHoldKeyConfigParam `json:"hold_key,omitzero"`
	// `hover`'s config overrides.
	Hover BetaBrowserHoverConfigParam `json:"hover,omitzero"`
	// `javascript_exec`'s config overrides.
	JavascriptExec BetaBrowserJavascriptExecConfigParam `json:"javascript_exec,omitzero"`
	// `key`'s config overrides.
	Key BetaBrowserKeyConfigParam `json:"key,omitzero"`
	// `left_click`'s config overrides.
	LeftClick BetaBrowserLeftClickConfigParam `json:"left_click,omitzero"`
	// `left_click_drag`'s config overrides.
	LeftClickDrag BetaBrowserLeftClickDragConfigParam `json:"left_click_drag,omitzero"`
	// `left_mouse_down`'s config overrides.
	LeftMouseDown BetaBrowserLeftMouseDownConfigParam `json:"left_mouse_down,omitzero"`
	// `left_mouse_up`'s config overrides.
	LeftMouseUp BetaBrowserLeftMouseUpConfigParam `json:"left_mouse_up,omitzero"`
	// `list_tabs`'s config overrides.
	ListTabs BetaBrowserListTabsConfigParam `json:"list_tabs,omitzero"`
	// `middle_click`'s config overrides.
	MiddleClick BetaBrowserMiddleClickConfigParam `json:"middle_click,omitzero"`
	// `mouse_move`'s config overrides.
	MouseMove BetaBrowserMouseMoveConfigParam `json:"mouse_move,omitzero"`
	// `navigate`'s config overrides.
	Navigate BetaBrowserNavigateConfigParam `json:"navigate,omitzero"`
	// `new_tab`'s config overrides.
	NewTab BetaBrowserNewTabConfigParam `json:"new_tab,omitzero"`
	// `read_console`'s config overrides.
	ReadConsole BetaBrowserReadConsoleConfigParam `json:"read_console,omitzero"`
	// `read_network`'s config overrides.
	ReadNetwork BetaBrowserReadNetworkConfigParam `json:"read_network,omitzero"`
	// `read_page`'s config overrides.
	ReadPage BetaBrowserReadPageConfigParam `json:"read_page,omitzero"`
	// `right_click`'s config overrides.
	RightClick BetaBrowserRightClickConfigParam `json:"right_click,omitzero"`
	// `screenshot`'s config overrides.
	Screenshot BetaBrowserScreenshotConfigParam `json:"screenshot,omitzero"`
	// `scroll`'s config overrides.
	Scroll BetaBrowserScrollConfigParam `json:"scroll,omitzero"`
	// `scroll_to`'s config overrides.
	ScrollTo BetaBrowserScrollToConfigParam `json:"scroll_to,omitzero"`
	// `switch_tab`'s config overrides.
	SwitchTab BetaBrowserSwitchTabConfigParam `json:"switch_tab,omitzero"`
	// `triple_click`'s config overrides.
	TripleClick BetaBrowserTripleClickConfigParam `json:"triple_click,omitzero"`
	// `type`'s config overrides.
	Type BetaBrowserTypeConfigParam `json:"type,omitzero"`
	// `wait`'s config overrides.
	Wait BetaBrowserWaitConfigParam `json:"wait,omitzero"`
	// `zoom`'s config overrides.
	Zoom BetaBrowserZoomConfigParam `json:"zoom,omitzero"`
	paramObj
}

func (r BetaBrowserToolsetConfigsParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaBrowserToolsetConfigsParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaBrowserToolsetConfigsParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `triple_click`'s config overrides.
type BetaBrowserTripleClickConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaBrowserTripleClickConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaBrowserTripleClickConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaBrowserTripleClickConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `type`'s config overrides.
type BetaBrowserTypeConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaBrowserTypeConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaBrowserTypeConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaBrowserTypeConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `wait`'s config overrides.
type BetaBrowserWaitConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaBrowserWaitConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaBrowserWaitConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaBrowserWaitConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `zoom`'s config overrides.
type BetaBrowserZoomConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaBrowserZoomConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaBrowserZoomConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaBrowserZoomConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

func NewBetaCacheControlEphemeralParam() BetaCacheControlEphemeralParam {
	return BetaCacheControlEphemeralParam{
		Type: "ephemeral",
	}
}

// This struct has a constant value, construct it with
// [NewBetaCacheControlEphemeralParam].
type BetaCacheControlEphemeralParam struct {
	// The time-to-live for the cache control breakpoint.
	//
	// This may be one the following values:
	//
	// - `5m`: 5 minutes
	// - `1h`: 1 hour
	//
	// Defaults to `5m`. See
	// [prompt caching pricing](https://platform.claude.com/docs/en/build-with-claude/prompt-caching)
	// for details.
	//
	// Any of "5m", "1h".
	TTL  BetaCacheControlEphemeralTTL `json:"ttl,omitzero"`
	Type constant.Ephemeral           `json:"type" default:"ephemeral"`
	paramObj
}

func (r BetaCacheControlEphemeralParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaCacheControlEphemeralParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaCacheControlEphemeralParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The time-to-live for the cache control breakpoint.
//
// This may be one the following values:
//
// - `5m`: 5 minutes
// - `1h`: 1 hour
//
// Defaults to `5m`. See
// [prompt caching pricing](https://platform.claude.com/docs/en/build-with-claude/prompt-caching)
// for details.
type BetaCacheControlEphemeralTTL string

const (
	BetaCacheControlEphemeralTTLTTL5m BetaCacheControlEphemeralTTL = "5m"
	BetaCacheControlEphemeralTTLTTL1h BetaCacheControlEphemeralTTL = "1h"
)

type BetaCacheCreation struct {
	// The number of input tokens used to create the 1 hour cache entry.
	Ephemeral1hInputTokens int64 `json:"ephemeral_1h_input_tokens" api:"required"`
	// The number of input tokens used to create the 5 minute cache entry.
	Ephemeral5mInputTokens int64 `json:"ephemeral_5m_input_tokens" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Ephemeral1hInputTokens respjson.Field
		Ephemeral5mInputTokens respjson.Field
		ExtraFields            map[string]respjson.Field
		raw                    string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaCacheCreation) RawJSON() string { return r.JSON.raw }
func (r *BetaCacheCreation) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaCacheMissMessagesChanged struct {
	// Approximate number of input tokens that would have been read from cache had the
	// prefix matched the previous request.
	CacheMissedInputTokens int64                    `json:"cache_missed_input_tokens" api:"required"`
	Type                   constant.MessagesChanged `json:"type" default:"messages_changed"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CacheMissedInputTokens respjson.Field
		Type                   respjson.Field
		ExtraFields            map[string]respjson.Field
		raw                    string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaCacheMissMessagesChanged) RawJSON() string { return r.JSON.raw }
func (r *BetaCacheMissMessagesChanged) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaCacheMissModelChanged struct {
	// Approximate number of input tokens that would have been read from cache had the
	// prefix matched the previous request.
	CacheMissedInputTokens int64                 `json:"cache_missed_input_tokens" api:"required"`
	Type                   constant.ModelChanged `json:"type" default:"model_changed"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CacheMissedInputTokens respjson.Field
		Type                   respjson.Field
		ExtraFields            map[string]respjson.Field
		raw                    string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaCacheMissModelChanged) RawJSON() string { return r.JSON.raw }
func (r *BetaCacheMissModelChanged) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaCacheMissPreviousMessageNotFound struct {
	Type constant.PreviousMessageNotFound `json:"type" default:"previous_message_not_found"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaCacheMissPreviousMessageNotFound) RawJSON() string { return r.JSON.raw }
func (r *BetaCacheMissPreviousMessageNotFound) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaCacheMissSystemChanged struct {
	// Approximate number of input tokens that would have been read from cache had the
	// prefix matched the previous request.
	CacheMissedInputTokens int64                  `json:"cache_missed_input_tokens" api:"required"`
	Type                   constant.SystemChanged `json:"type" default:"system_changed"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CacheMissedInputTokens respjson.Field
		Type                   respjson.Field
		ExtraFields            map[string]respjson.Field
		raw                    string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaCacheMissSystemChanged) RawJSON() string { return r.JSON.raw }
func (r *BetaCacheMissSystemChanged) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaCacheMissToolsChanged struct {
	// Approximate number of input tokens that would have been read from cache had the
	// prefix matched the previous request.
	CacheMissedInputTokens int64                 `json:"cache_missed_input_tokens" api:"required"`
	Type                   constant.ToolsChanged `json:"type" default:"tools_changed"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CacheMissedInputTokens respjson.Field
		Type                   respjson.Field
		ExtraFields            map[string]respjson.Field
		raw                    string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaCacheMissToolsChanged) RawJSON() string { return r.JSON.raw }
func (r *BetaCacheMissToolsChanged) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaCacheMissUnavailable struct {
	Type constant.Unavailable `json:"type" default:"unavailable"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaCacheMissUnavailable) RawJSON() string { return r.JSON.raw }
func (r *BetaCacheMissUnavailable) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaCitationCharLocation struct {
	CitedText      string                `json:"cited_text" api:"required"`
	DocumentIndex  int64                 `json:"document_index" api:"required"`
	DocumentTitle  string                `json:"document_title" api:"required"`
	EndCharIndex   int64                 `json:"end_char_index" api:"required"`
	FileID         string                `json:"file_id" api:"required"`
	StartCharIndex int64                 `json:"start_char_index" api:"required"`
	Type           constant.CharLocation `json:"type" default:"char_location"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CitedText      respjson.Field
		DocumentIndex  respjson.Field
		DocumentTitle  respjson.Field
		EndCharIndex   respjson.Field
		FileID         respjson.Field
		StartCharIndex respjson.Field
		Type           respjson.Field
		ExtraFields    map[string]respjson.Field
		raw            string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaCitationCharLocation) RawJSON() string { return r.JSON.raw }
func (r *BetaCitationCharLocation) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties CitedText, DocumentIndex, DocumentTitle, EndCharIndex,
// StartCharIndex, Type are required.
type BetaCitationCharLocationParam struct {
	DocumentTitle  param.Opt[string] `json:"document_title,omitzero" api:"required"`
	CitedText      string            `json:"cited_text" api:"required"`
	DocumentIndex  int64             `json:"document_index" api:"required"`
	EndCharIndex   int64             `json:"end_char_index" api:"required"`
	StartCharIndex int64             `json:"start_char_index" api:"required"`
	// This field can be elided, and will marshal its zero value as "char_location".
	Type constant.CharLocation `json:"type" default:"char_location"`
	paramObj
}

func (r BetaCitationCharLocationParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaCitationCharLocationParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaCitationCharLocationParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaCitationConfig struct {
	Enabled bool `json:"enabled" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Enabled     respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaCitationConfig) RawJSON() string { return r.JSON.raw }
func (r *BetaCitationConfig) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaCitationContentBlockLocation struct {
	// The full text of the cited block range, concatenated.
	//
	// Always equals the contents of `content[start_block_index:end_block_index]`
	// joined together. The text block is the minimal citable unit; this field is never
	// a substring of a single block. Not counted toward output tokens, and not counted
	// toward input tokens when sent back in subsequent turns.
	CitedText     string `json:"cited_text" api:"required"`
	DocumentIndex int64  `json:"document_index" api:"required"`
	DocumentTitle string `json:"document_title" api:"required"`
	// Exclusive 0-based end index of the cited block range in the source's `content`
	// array.
	//
	// Always greater than `start_block_index`; a single-block citation has
	// `end_block_index = start_block_index + 1`.
	EndBlockIndex int64  `json:"end_block_index" api:"required"`
	FileID        string `json:"file_id" api:"required"`
	// 0-based index of the first cited block in the source's `content` array.
	StartBlockIndex int64                         `json:"start_block_index" api:"required"`
	Type            constant.ContentBlockLocation `json:"type" default:"content_block_location"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CitedText       respjson.Field
		DocumentIndex   respjson.Field
		DocumentTitle   respjson.Field
		EndBlockIndex   respjson.Field
		FileID          respjson.Field
		StartBlockIndex respjson.Field
		Type            respjson.Field
		ExtraFields     map[string]respjson.Field
		raw             string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaCitationContentBlockLocation) RawJSON() string { return r.JSON.raw }
func (r *BetaCitationContentBlockLocation) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties CitedText, DocumentIndex, DocumentTitle, EndBlockIndex,
// StartBlockIndex, Type are required.
type BetaCitationContentBlockLocationParam struct {
	DocumentTitle param.Opt[string] `json:"document_title,omitzero" api:"required"`
	// The full text of the cited block range, concatenated.
	//
	// Always equals the contents of `content[start_block_index:end_block_index]`
	// joined together. The text block is the minimal citable unit; this field is never
	// a substring of a single block. Not counted toward output tokens, and not counted
	// toward input tokens when sent back in subsequent turns.
	CitedText     string `json:"cited_text" api:"required"`
	DocumentIndex int64  `json:"document_index" api:"required"`
	// Exclusive 0-based end index of the cited block range in the source's `content`
	// array.
	//
	// Always greater than `start_block_index`; a single-block citation has
	// `end_block_index = start_block_index + 1`.
	EndBlockIndex int64 `json:"end_block_index" api:"required"`
	// 0-based index of the first cited block in the source's `content` array.
	StartBlockIndex int64 `json:"start_block_index" api:"required"`
	// This field can be elided, and will marshal its zero value as
	// "content_block_location".
	Type constant.ContentBlockLocation `json:"type" default:"content_block_location"`
	paramObj
}

func (r BetaCitationContentBlockLocationParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaCitationContentBlockLocationParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaCitationContentBlockLocationParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaCitationPageLocation struct {
	CitedText       string                `json:"cited_text" api:"required"`
	DocumentIndex   int64                 `json:"document_index" api:"required"`
	DocumentTitle   string                `json:"document_title" api:"required"`
	EndPageNumber   int64                 `json:"end_page_number" api:"required"`
	FileID          string                `json:"file_id" api:"required"`
	StartPageNumber int64                 `json:"start_page_number" api:"required"`
	Type            constant.PageLocation `json:"type" default:"page_location"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CitedText       respjson.Field
		DocumentIndex   respjson.Field
		DocumentTitle   respjson.Field
		EndPageNumber   respjson.Field
		FileID          respjson.Field
		StartPageNumber respjson.Field
		Type            respjson.Field
		ExtraFields     map[string]respjson.Field
		raw             string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaCitationPageLocation) RawJSON() string { return r.JSON.raw }
func (r *BetaCitationPageLocation) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties CitedText, DocumentIndex, DocumentTitle, EndPageNumber,
// StartPageNumber, Type are required.
type BetaCitationPageLocationParam struct {
	DocumentTitle   param.Opt[string] `json:"document_title,omitzero" api:"required"`
	CitedText       string            `json:"cited_text" api:"required"`
	DocumentIndex   int64             `json:"document_index" api:"required"`
	EndPageNumber   int64             `json:"end_page_number" api:"required"`
	StartPageNumber int64             `json:"start_page_number" api:"required"`
	// This field can be elided, and will marshal its zero value as "page_location".
	Type constant.PageLocation `json:"type" default:"page_location"`
	paramObj
}

func (r BetaCitationPageLocationParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaCitationPageLocationParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaCitationPageLocationParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaCitationSearchResultLocation struct {
	// The full text of the cited block range, concatenated.
	//
	// Always equals the contents of `content[start_block_index:end_block_index]`
	// joined together. The text block is the minimal citable unit; this field is never
	// a substring of a single block. Not counted toward output tokens, and not counted
	// toward input tokens when sent back in subsequent turns.
	CitedText string `json:"cited_text" api:"required"`
	// Exclusive 0-based end index of the cited block range in the source's `content`
	// array.
	//
	// Always greater than `start_block_index`; a single-block citation has
	// `end_block_index = start_block_index + 1`.
	EndBlockIndex int64 `json:"end_block_index" api:"required"`
	// 0-based index of the cited search result among all `search_result` content
	// blocks in the request, in the order they appear across messages and tool
	// results.
	//
	// Counted separately from `document_index`; server-side web search results are not
	// included in this count.
	SearchResultIndex int64  `json:"search_result_index" api:"required"`
	Source            string `json:"source" api:"required"`
	// 0-based index of the first cited block in the source's `content` array.
	StartBlockIndex int64                         `json:"start_block_index" api:"required"`
	Title           string                        `json:"title" api:"required"`
	Type            constant.SearchResultLocation `json:"type" default:"search_result_location"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CitedText         respjson.Field
		EndBlockIndex     respjson.Field
		SearchResultIndex respjson.Field
		Source            respjson.Field
		StartBlockIndex   respjson.Field
		Title             respjson.Field
		Type              respjson.Field
		ExtraFields       map[string]respjson.Field
		raw               string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaCitationSearchResultLocation) RawJSON() string { return r.JSON.raw }
func (r *BetaCitationSearchResultLocation) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties CitedText, EndBlockIndex, SearchResultIndex, Source,
// StartBlockIndex, Title, Type are required.
type BetaCitationSearchResultLocationParam struct {
	Title param.Opt[string] `json:"title,omitzero" api:"required"`
	// The full text of the cited block range, concatenated.
	//
	// Always equals the contents of `content[start_block_index:end_block_index]`
	// joined together. The text block is the minimal citable unit; this field is never
	// a substring of a single block. Not counted toward output tokens, and not counted
	// toward input tokens when sent back in subsequent turns.
	CitedText string `json:"cited_text" api:"required"`
	// Exclusive 0-based end index of the cited block range in the source's `content`
	// array.
	//
	// Always greater than `start_block_index`; a single-block citation has
	// `end_block_index = start_block_index + 1`.
	EndBlockIndex int64 `json:"end_block_index" api:"required"`
	// 0-based index of the cited search result among all `search_result` content
	// blocks in the request, in the order they appear across messages and tool
	// results.
	//
	// Counted separately from `document_index`; server-side web search results are not
	// included in this count.
	SearchResultIndex int64  `json:"search_result_index" api:"required"`
	Source            string `json:"source" api:"required"`
	// 0-based index of the first cited block in the source's `content` array.
	StartBlockIndex int64 `json:"start_block_index" api:"required"`
	// This field can be elided, and will marshal its zero value as
	// "search_result_location".
	Type constant.SearchResultLocation `json:"type" default:"search_result_location"`
	paramObj
}

func (r BetaCitationSearchResultLocationParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaCitationSearchResultLocationParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaCitationSearchResultLocationParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties CitedText, EncryptedIndex, Title, Type, URL are required.
type BetaCitationWebSearchResultLocationParam struct {
	Title          param.Opt[string] `json:"title,omitzero" api:"required"`
	CitedText      string            `json:"cited_text" api:"required"`
	EncryptedIndex string            `json:"encrypted_index" api:"required"`
	URL            string            `json:"url" api:"required"`
	// This field can be elided, and will marshal its zero value as
	// "web_search_result_location".
	Type constant.WebSearchResultLocation `json:"type" default:"web_search_result_location"`
	paramObj
}

func (r BetaCitationWebSearchResultLocationParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaCitationWebSearchResultLocationParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaCitationWebSearchResultLocationParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaCitationsConfigParam struct {
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaCitationsConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaCitationsConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaCitationsConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaCitationsDelta struct {
	Citation BetaCitationsDeltaCitationUnion `json:"citation" api:"required"`
	Type     constant.CitationsDelta         `json:"type" default:"citations_delta"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Citation    respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaCitationsDelta) RawJSON() string { return r.JSON.raw }
func (r *BetaCitationsDelta) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// BetaCitationsDeltaCitationUnion contains all possible properties and values from
// [BetaCitationCharLocation], [BetaCitationPageLocation],
// [BetaCitationContentBlockLocation], [BetaCitationsWebSearchResultLocation],
// [BetaCitationSearchResultLocation].
//
// Use the [BetaCitationsDeltaCitationUnion.AsAny] method to switch on the variant.
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
type BetaCitationsDeltaCitationUnion struct {
	CitedText     string `json:"cited_text"`
	DocumentIndex int64  `json:"document_index"`
	DocumentTitle string `json:"document_title"`
	// This field is from variant [BetaCitationCharLocation].
	EndCharIndex int64  `json:"end_char_index"`
	FileID       string `json:"file_id"`
	// This field is from variant [BetaCitationCharLocation].
	StartCharIndex int64 `json:"start_char_index"`
	// Any of "char_location", "page_location", "content_block_location",
	// "web_search_result_location", "search_result_location".
	Type string `json:"type"`
	// This field is from variant [BetaCitationPageLocation].
	EndPageNumber int64 `json:"end_page_number"`
	// This field is from variant [BetaCitationPageLocation].
	StartPageNumber int64 `json:"start_page_number"`
	EndBlockIndex   int64 `json:"end_block_index"`
	StartBlockIndex int64 `json:"start_block_index"`
	// This field is from variant [BetaCitationsWebSearchResultLocation].
	EncryptedIndex string `json:"encrypted_index"`
	Title          string `json:"title"`
	// This field is from variant [BetaCitationsWebSearchResultLocation].
	URL string `json:"url"`
	// This field is from variant [BetaCitationSearchResultLocation].
	SearchResultIndex int64 `json:"search_result_index"`
	// This field is from variant [BetaCitationSearchResultLocation].
	Source string `json:"source"`
	JSON   struct {
		CitedText         respjson.Field
		DocumentIndex     respjson.Field
		DocumentTitle     respjson.Field
		EndCharIndex      respjson.Field
		FileID            respjson.Field
		StartCharIndex    respjson.Field
		Type              respjson.Field
		EndPageNumber     respjson.Field
		StartPageNumber   respjson.Field
		EndBlockIndex     respjson.Field
		StartBlockIndex   respjson.Field
		EncryptedIndex    respjson.Field
		Title             respjson.Field
		URL               respjson.Field
		SearchResultIndex respjson.Field
		Source            respjson.Field
		raw               string
	} `json:"-"`
}

// anyBetaCitationsDeltaCitation is implemented by each variant of
// [BetaCitationsDeltaCitationUnion] to add type safety for the return type of
// [BetaCitationsDeltaCitationUnion.AsAny]
type anyBetaCitationsDeltaCitation interface {
	implBetaCitationsDeltaCitationUnion()
}

func (BetaCitationCharLocation) implBetaCitationsDeltaCitationUnion()             {}
func (BetaCitationPageLocation) implBetaCitationsDeltaCitationUnion()             {}
func (BetaCitationContentBlockLocation) implBetaCitationsDeltaCitationUnion()     {}
func (BetaCitationsWebSearchResultLocation) implBetaCitationsDeltaCitationUnion() {}
func (BetaCitationSearchResultLocation) implBetaCitationsDeltaCitationUnion()     {}

// Use the following switch statement to find the correct variant
//
//	switch variant := BetaCitationsDeltaCitationUnion.AsAny().(type) {
//	case anthropic.BetaCitationCharLocation:
//	case anthropic.BetaCitationPageLocation:
//	case anthropic.BetaCitationContentBlockLocation:
//	case anthropic.BetaCitationsWebSearchResultLocation:
//	case anthropic.BetaCitationSearchResultLocation:
//	default:
//	  fmt.Errorf("no variant present")
//	}
func (u BetaCitationsDeltaCitationUnion) AsAny() anyBetaCitationsDeltaCitation {
	switch u.Type {
	case "char_location":
		return u.AsCharLocation()
	case "page_location":
		return u.AsPageLocation()
	case "content_block_location":
		return u.AsContentBlockLocation()
	case "web_search_result_location":
		return u.AsWebSearchResultLocation()
	case "search_result_location":
		return u.AsSearchResultLocation()
	}
	return nil
}

func (u BetaCitationsDeltaCitationUnion) AsCharLocation() (v BetaCitationCharLocation) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaCitationsDeltaCitationUnion) AsPageLocation() (v BetaCitationPageLocation) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaCitationsDeltaCitationUnion) AsContentBlockLocation() (v BetaCitationContentBlockLocation) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaCitationsDeltaCitationUnion) AsWebSearchResultLocation() (v BetaCitationsWebSearchResultLocation) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaCitationsDeltaCitationUnion) AsSearchResultLocation() (v BetaCitationSearchResultLocation) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u BetaCitationsDeltaCitationUnion) RawJSON() string { return u.JSON.raw }

func (r *BetaCitationsDeltaCitationUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaCitationsWebSearchResultLocation struct {
	CitedText      string                           `json:"cited_text" api:"required"`
	EncryptedIndex string                           `json:"encrypted_index" api:"required"`
	Title          string                           `json:"title" api:"required"`
	Type           constant.WebSearchResultLocation `json:"type" default:"web_search_result_location"`
	URL            string                           `json:"url" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CitedText      respjson.Field
		EncryptedIndex respjson.Field
		Title          respjson.Field
		Type           respjson.Field
		URL            respjson.Field
		ExtraFields    map[string]respjson.Field
		raw            string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaCitationsWebSearchResultLocation) RawJSON() string { return r.JSON.raw }
func (r *BetaCitationsWebSearchResultLocation) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The property Type is required.
type BetaClearThinking20251015EditParam struct {
	// Number of most recent assistant turns to keep thinking blocks for. Older turns
	// will have their thinking blocks removed.
	Keep BetaClearThinking20251015EditKeepUnionParam `json:"keep,omitzero"`
	// This field can be elided, and will marshal its zero value as
	// "clear_thinking_20251015".
	Type constant.ClearThinking20251015 `json:"type" default:"clear_thinking_20251015"`
	paramObj
}

func (r BetaClearThinking20251015EditParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaClearThinking20251015EditParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaClearThinking20251015EditParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Only one field can be non-zero.
//
// Use [param.IsOmitted] to confirm if a field is set.
type BetaClearThinking20251015EditKeepUnionParam struct {
	OfThinkingTurns    *BetaThinkingTurnsParam    `json:",omitzero,inline"`
	OfAllThinkingTurns *BetaAllThinkingTurnsParam `json:",omitzero,inline"`
	// Construct this variant with constant.ValueOf[constant.All]()
	OfAll constant.All `json:",omitzero,inline"`
	paramUnion
}

func (u BetaClearThinking20251015EditKeepUnionParam) MarshalJSON() ([]byte, error) {
	return param.MarshalUnion(u, u.OfThinkingTurns, u.OfAllThinkingTurns, u.OfAll)
}
func (u *BetaClearThinking20251015EditKeepUnionParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, u)
}

func (u *BetaClearThinking20251015EditKeepUnionParam) asAny() any {
	if !param.IsOmitted(u.OfThinkingTurns) {
		return u.OfThinkingTurns
	} else if !param.IsOmitted(u.OfAllThinkingTurns) {
		return u.OfAllThinkingTurns
	} else if !param.IsOmitted(u.OfAll) {
		return &u.OfAll
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaClearThinking20251015EditKeepUnionParam) GetValue() *int64 {
	if vt := u.OfThinkingTurns; vt != nil {
		return &vt.Value
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaClearThinking20251015EditKeepUnionParam) GetType() *string {
	if vt := u.OfThinkingTurns; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfAllThinkingTurns; vt != nil {
		return (*string)(&vt.Type)
	}
	return nil
}

type BetaClearThinking20251015EditResponse struct {
	// Number of input tokens cleared by this edit.
	ClearedInputTokens int64 `json:"cleared_input_tokens" api:"required"`
	// Number of thinking turns that were cleared.
	ClearedThinkingTurns int64 `json:"cleared_thinking_turns" api:"required"`
	// The type of context management edit applied.
	Type constant.ClearThinking20251015 `json:"type" default:"clear_thinking_20251015"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ClearedInputTokens   respjson.Field
		ClearedThinkingTurns respjson.Field
		Type                 respjson.Field
		ExtraFields          map[string]respjson.Field
		raw                  string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaClearThinking20251015EditResponse) RawJSON() string { return r.JSON.raw }
func (r *BetaClearThinking20251015EditResponse) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The property Type is required.
type BetaClearToolUses20250919EditParam struct {
	// Whether to clear all tool inputs (bool) or specific tool inputs to clear (list)
	ClearToolInputs BetaClearToolUses20250919EditClearToolInputsUnionParam `json:"clear_tool_inputs,omitzero"`
	// Tool names whose uses are preserved from clearing
	ExcludeTools []string `json:"exclude_tools,omitzero"`
	// Minimum number of tokens that must be cleared when triggered. Context will only
	// be modified if at least this many tokens can be removed.
	ClearAtLeast BetaInputTokensClearAtLeastParam `json:"clear_at_least,omitzero"`
	// Number of tool uses to retain in the conversation
	Keep BetaToolUsesKeepParam `json:"keep,omitzero"`
	// Condition that triggers the context management strategy
	Trigger BetaClearToolUses20250919EditTriggerUnionParam `json:"trigger,omitzero"`
	// This field can be elided, and will marshal its zero value as
	// "clear_tool_uses_20250919".
	Type constant.ClearToolUses20250919 `json:"type" default:"clear_tool_uses_20250919"`
	paramObj
}

func (r BetaClearToolUses20250919EditParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaClearToolUses20250919EditParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaClearToolUses20250919EditParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Only one field can be non-zero.
//
// Use [param.IsOmitted] to confirm if a field is set.
type BetaClearToolUses20250919EditClearToolInputsUnionParam struct {
	OfBool        param.Opt[bool] `json:",omitzero,inline"`
	OfStringArray []string        `json:",omitzero,inline"`
	paramUnion
}

func (u BetaClearToolUses20250919EditClearToolInputsUnionParam) MarshalJSON() ([]byte, error) {
	return param.MarshalUnion(u, u.OfBool, u.OfStringArray)
}
func (u *BetaClearToolUses20250919EditClearToolInputsUnionParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, u)
}

func (u *BetaClearToolUses20250919EditClearToolInputsUnionParam) asAny() any {
	if !param.IsOmitted(u.OfBool) {
		return &u.OfBool.Value
	} else if !param.IsOmitted(u.OfStringArray) {
		return &u.OfStringArray
	}
	return nil
}

// Only one field can be non-zero.
//
// Use [param.IsOmitted] to confirm if a field is set.
type BetaClearToolUses20250919EditTriggerUnionParam struct {
	OfInputTokens *BetaInputTokensTriggerParam `json:",omitzero,inline"`
	OfToolUses    *BetaToolUsesTriggerParam    `json:",omitzero,inline"`
	paramUnion
}

func (u BetaClearToolUses20250919EditTriggerUnionParam) MarshalJSON() ([]byte, error) {
	return param.MarshalUnion(u, u.OfInputTokens, u.OfToolUses)
}
func (u *BetaClearToolUses20250919EditTriggerUnionParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, u)
}

func (u *BetaClearToolUses20250919EditTriggerUnionParam) asAny() any {
	if !param.IsOmitted(u.OfInputTokens) {
		return u.OfInputTokens
	} else if !param.IsOmitted(u.OfToolUses) {
		return u.OfToolUses
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaClearToolUses20250919EditTriggerUnionParam) GetType() *string {
	if vt := u.OfInputTokens; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfToolUses; vt != nil {
		return (*string)(&vt.Type)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaClearToolUses20250919EditTriggerUnionParam) GetValue() *int64 {
	if vt := u.OfInputTokens; vt != nil {
		return (*int64)(&vt.Value)
	} else if vt := u.OfToolUses; vt != nil {
		return (*int64)(&vt.Value)
	}
	return nil
}

func init() {
	apijson.RegisterUnion[BetaClearToolUses20250919EditTriggerUnionParam](
		"type",
		apijson.Discriminator[BetaInputTokensTriggerParam]("input_tokens"),
		apijson.Discriminator[BetaToolUsesTriggerParam]("tool_uses"),
	)
}

type BetaClearToolUses20250919EditResponse struct {
	// Number of input tokens cleared by this edit.
	ClearedInputTokens int64 `json:"cleared_input_tokens" api:"required"`
	// Number of tool uses that were cleared.
	ClearedToolUses int64 `json:"cleared_tool_uses" api:"required"`
	// The type of context management edit applied.
	Type constant.ClearToolUses20250919 `json:"type" default:"clear_tool_uses_20250919"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ClearedInputTokens respjson.Field
		ClearedToolUses    respjson.Field
		Type               respjson.Field
		ExtraFields        map[string]respjson.Field
		raw                string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaClearToolUses20250919EditResponse) RawJSON() string { return r.JSON.raw }
func (r *BetaClearToolUses20250919EditResponse) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaCodeExecutionOutputBlock struct {
	FileID string                       `json:"file_id" api:"required"`
	Type   constant.CodeExecutionOutput `json:"type" default:"code_execution_output"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		FileID      respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaCodeExecutionOutputBlock) RawJSON() string { return r.JSON.raw }
func (r *BetaCodeExecutionOutputBlock) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties FileID, Type are required.
type BetaCodeExecutionOutputBlockParam struct {
	FileID string `json:"file_id" api:"required"`
	// This field can be elided, and will marshal its zero value as
	// "code_execution_output".
	Type constant.CodeExecutionOutput `json:"type" default:"code_execution_output"`
	paramObj
}

func (r BetaCodeExecutionOutputBlockParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaCodeExecutionOutputBlockParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaCodeExecutionOutputBlockParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaCodeExecutionResultBlock struct {
	Content    []BetaCodeExecutionOutputBlock `json:"content" api:"required"`
	ReturnCode int64                          `json:"return_code" api:"required"`
	Stderr     string                         `json:"stderr" api:"required"`
	Stdout     string                         `json:"stdout" api:"required"`
	Type       constant.CodeExecutionResult   `json:"type" default:"code_execution_result"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Content     respjson.Field
		ReturnCode  respjson.Field
		Stderr      respjson.Field
		Stdout      respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaCodeExecutionResultBlock) RawJSON() string { return r.JSON.raw }
func (r *BetaCodeExecutionResultBlock) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties Content, ReturnCode, Stderr, Stdout, Type are required.
type BetaCodeExecutionResultBlockParam struct {
	Content    []BetaCodeExecutionOutputBlockParam `json:"content,omitzero" api:"required"`
	ReturnCode int64                               `json:"return_code" api:"required"`
	Stderr     string                              `json:"stderr" api:"required"`
	Stdout     string                              `json:"stdout" api:"required"`
	// This field can be elided, and will marshal its zero value as
	// "code_execution_result".
	Type constant.CodeExecutionResult `json:"type" default:"code_execution_result"`
	paramObj
}

func (r BetaCodeExecutionResultBlockParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaCodeExecutionResultBlockParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaCodeExecutionResultBlockParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties Name, Type are required.
type BetaCodeExecutionTool20250522Param struct {
	// If true, tool will not be included in initial system prompt. Only loaded when
	// returned via tool_reference from tool search.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// When true, guarantees schema validation on tool names and inputs
	Strict param.Opt[bool] `json:"strict,omitzero"`
	// Any of "direct", "code_execution_20250825", "code_execution_20260120",
	// "code_execution_20260521".
	AllowedCallers []string `json:"allowed_callers,omitzero"`
	// Create a cache control breakpoint at this content block.
	CacheControl BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	// Name of the tool.
	//
	// This is how the tool will be called by the model and in `tool_use` blocks.
	//
	// This field can be elided, and will marshal its zero value as "code_execution".
	Name constant.CodeExecution `json:"name" default:"code_execution"`
	// This field can be elided, and will marshal its zero value as
	// "code_execution_20250522".
	Type constant.CodeExecution20250522 `json:"type" default:"code_execution_20250522"`
	paramObj
}

func (r BetaCodeExecutionTool20250522Param) MarshalJSON() (data []byte, err error) {
	type shadow BetaCodeExecutionTool20250522Param
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaCodeExecutionTool20250522Param) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties Name, Type are required.
type BetaCodeExecutionTool20250825Param struct {
	// If true, tool will not be included in initial system prompt. Only loaded when
	// returned via tool_reference from tool search.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// When true, guarantees schema validation on tool names and inputs
	Strict param.Opt[bool] `json:"strict,omitzero"`
	// Any of "direct", "code_execution_20250825", "code_execution_20260120",
	// "code_execution_20260521".
	AllowedCallers []string `json:"allowed_callers,omitzero"`
	// Create a cache control breakpoint at this content block.
	CacheControl BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	// Name of the tool.
	//
	// This is how the tool will be called by the model and in `tool_use` blocks.
	//
	// This field can be elided, and will marshal its zero value as "code_execution".
	Name constant.CodeExecution `json:"name" default:"code_execution"`
	// This field can be elided, and will marshal its zero value as
	// "code_execution_20250825".
	Type constant.CodeExecution20250825 `json:"type" default:"code_execution_20250825"`
	paramObj
}

func (r BetaCodeExecutionTool20250825Param) MarshalJSON() (data []byte, err error) {
	type shadow BetaCodeExecutionTool20250825Param
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaCodeExecutionTool20250825Param) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Code execution tool with REPL state persistence (daemon mode + gVisor
// checkpoint).
//
// The properties Name, Type are required.
type BetaCodeExecutionTool20260120Param struct {
	// If true, tool will not be included in initial system prompt. Only loaded when
	// returned via tool_reference from tool search.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// When true, guarantees schema validation on tool names and inputs
	Strict param.Opt[bool] `json:"strict,omitzero"`
	// Any of "direct", "code_execution_20250825", "code_execution_20260120",
	// "code_execution_20260521".
	AllowedCallers []string `json:"allowed_callers,omitzero"`
	// Create a cache control breakpoint at this content block.
	CacheControl BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	// Name of the tool.
	//
	// This is how the tool will be called by the model and in `tool_use` blocks.
	//
	// This field can be elided, and will marshal its zero value as "code_execution".
	Name constant.CodeExecution `json:"name" default:"code_execution"`
	// This field can be elided, and will marshal its zero value as
	// "code_execution_20260120".
	Type constant.CodeExecution20260120 `json:"type" default:"code_execution_20260120"`
	paramObj
}

func (r BetaCodeExecutionTool20260120Param) MarshalJSON() (data []byte, err error) {
	type shadow BetaCodeExecutionTool20260120Param
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaCodeExecutionTool20260120Param) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Code execution tool with REPL state persistence.
//
// The properties Name, Type are required.
type BetaCodeExecutionTool20260521Param struct {
	// If true, tool will not be included in initial system prompt. Only loaded when
	// returned via tool_reference from tool search.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// When true, guarantees schema validation on tool names and inputs
	Strict param.Opt[bool] `json:"strict,omitzero"`
	// Any of "direct", "code_execution_20250825", "code_execution_20260120",
	// "code_execution_20260521".
	AllowedCallers []string `json:"allowed_callers,omitzero"`
	// Create a cache control breakpoint at this content block.
	CacheControl BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	// Name of the tool.
	//
	// This is how the tool will be called by the model and in `tool_use` blocks.
	//
	// This field can be elided, and will marshal its zero value as "code_execution".
	Name constant.CodeExecution `json:"name" default:"code_execution"`
	// This field can be elided, and will marshal its zero value as
	// "code_execution_20260521".
	Type constant.CodeExecution20260521 `json:"type" default:"code_execution_20260521"`
	paramObj
}

func (r BetaCodeExecutionTool20260521Param) MarshalJSON() (data []byte, err error) {
	type shadow BetaCodeExecutionTool20260521Param
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaCodeExecutionTool20260521Param) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaCodeExecutionToolResultBlock struct {
	// Code execution result with encrypted stdout for PFC + web_search results.
	Content   BetaCodeExecutionToolResultBlockContentUnion `json:"content" api:"required"`
	ToolUseID string                                       `json:"tool_use_id" api:"required"`
	Type      constant.CodeExecutionToolResult             `json:"type" default:"code_execution_tool_result"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Content     respjson.Field
		ToolUseID   respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaCodeExecutionToolResultBlock) RawJSON() string { return r.JSON.raw }
func (r *BetaCodeExecutionToolResultBlock) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// BetaCodeExecutionToolResultBlockContentUnion contains all possible properties
// and values from [BetaCodeExecutionToolResultError],
// [BetaCodeExecutionResultBlock], [BetaEncryptedCodeExecutionResultBlock].
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
type BetaCodeExecutionToolResultBlockContentUnion struct {
	// This field is from variant [BetaCodeExecutionToolResultError].
	ErrorCode  BetaCodeExecutionToolResultErrorCode `json:"error_code"`
	Type       string                               `json:"type"`
	Content    []BetaCodeExecutionOutputBlock       `json:"content"`
	ReturnCode int64                                `json:"return_code"`
	Stderr     string                               `json:"stderr"`
	// This field is from variant [BetaCodeExecutionResultBlock].
	Stdout string `json:"stdout"`
	// This field is from variant [BetaEncryptedCodeExecutionResultBlock].
	EncryptedStdout string `json:"encrypted_stdout"`
	JSON            struct {
		ErrorCode       respjson.Field
		Type            respjson.Field
		Content         respjson.Field
		ReturnCode      respjson.Field
		Stderr          respjson.Field
		Stdout          respjson.Field
		EncryptedStdout respjson.Field
		raw             string
	} `json:"-"`
}

func (u BetaCodeExecutionToolResultBlockContentUnion) AsResponseCodeExecutionToolResultError() (v BetaCodeExecutionToolResultError) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaCodeExecutionToolResultBlockContentUnion) AsResponseCodeExecutionResultBlock() (v BetaCodeExecutionResultBlock) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaCodeExecutionToolResultBlockContentUnion) AsResponseEncryptedCodeExecutionResultBlock() (v BetaEncryptedCodeExecutionResultBlock) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u BetaCodeExecutionToolResultBlockContentUnion) RawJSON() string { return u.JSON.raw }

func (r *BetaCodeExecutionToolResultBlockContentUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties Content, ToolUseID, Type are required.
type BetaCodeExecutionToolResultBlockParam struct {
	// Code execution result with encrypted stdout for PFC + web_search results.
	Content   BetaCodeExecutionToolResultBlockParamContentUnion `json:"content,omitzero" api:"required"`
	ToolUseID string                                            `json:"tool_use_id" api:"required"`
	// Create a cache control breakpoint at this content block.
	CacheControl BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	// This field can be elided, and will marshal its zero value as
	// "code_execution_tool_result".
	Type constant.CodeExecutionToolResult `json:"type" default:"code_execution_tool_result"`
	paramObj
}

func (r BetaCodeExecutionToolResultBlockParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaCodeExecutionToolResultBlockParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaCodeExecutionToolResultBlockParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

func BetaNewCodeExecutionToolRequestError(errorCode BetaCodeExecutionToolResultErrorCode) BetaCodeExecutionToolResultBlockParamContentUnion {
	var variant BetaCodeExecutionToolResultErrorParam
	variant.ErrorCode = errorCode
	return BetaCodeExecutionToolResultBlockParamContentUnion{OfError: &variant}
}

// Only one field can be non-zero.
//
// Use [param.IsOmitted] to confirm if a field is set.
type BetaCodeExecutionToolResultBlockParamContentUnion struct {
	OfError                                    *BetaCodeExecutionToolResultErrorParam      `json:",omitzero,inline"`
	OfResultBlock                              *BetaCodeExecutionResultBlockParam          `json:",omitzero,inline"`
	OfRequestEncryptedCodeExecutionResultBlock *BetaEncryptedCodeExecutionResultBlockParam `json:",omitzero,inline"`
	paramUnion
}

func (u BetaCodeExecutionToolResultBlockParamContentUnion) MarshalJSON() ([]byte, error) {
	return param.MarshalUnion(u, u.OfError, u.OfResultBlock, u.OfRequestEncryptedCodeExecutionResultBlock)
}
func (u *BetaCodeExecutionToolResultBlockParamContentUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, u)
}

func (u *BetaCodeExecutionToolResultBlockParamContentUnion) asAny() any {
	if !param.IsOmitted(u.OfError) {
		return u.OfError
	} else if !param.IsOmitted(u.OfResultBlock) {
		return u.OfResultBlock
	} else if !param.IsOmitted(u.OfRequestEncryptedCodeExecutionResultBlock) {
		return u.OfRequestEncryptedCodeExecutionResultBlock
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaCodeExecutionToolResultBlockParamContentUnion) GetErrorCode() *string {
	if vt := u.OfError; vt != nil {
		return (*string)(&vt.ErrorCode)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaCodeExecutionToolResultBlockParamContentUnion) GetStdout() *string {
	if vt := u.OfResultBlock; vt != nil {
		return &vt.Stdout
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaCodeExecutionToolResultBlockParamContentUnion) GetEncryptedStdout() *string {
	if vt := u.OfRequestEncryptedCodeExecutionResultBlock; vt != nil {
		return &vt.EncryptedStdout
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaCodeExecutionToolResultBlockParamContentUnion) GetType() *string {
	if vt := u.OfError; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfResultBlock; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfRequestEncryptedCodeExecutionResultBlock; vt != nil {
		return (*string)(&vt.Type)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaCodeExecutionToolResultBlockParamContentUnion) GetReturnCode() *int64 {
	if vt := u.OfResultBlock; vt != nil {
		return (*int64)(&vt.ReturnCode)
	} else if vt := u.OfRequestEncryptedCodeExecutionResultBlock; vt != nil {
		return (*int64)(&vt.ReturnCode)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaCodeExecutionToolResultBlockParamContentUnion) GetStderr() *string {
	if vt := u.OfResultBlock; vt != nil {
		return (*string)(&vt.Stderr)
	} else if vt := u.OfRequestEncryptedCodeExecutionResultBlock; vt != nil {
		return (*string)(&vt.Stderr)
	}
	return nil
}

// Returns a pointer to the underlying variant's Content property, if present.
func (u BetaCodeExecutionToolResultBlockParamContentUnion) GetContent() []BetaCodeExecutionOutputBlockParam {
	if vt := u.OfResultBlock; vt != nil {
		return vt.Content
	} else if vt := u.OfRequestEncryptedCodeExecutionResultBlock; vt != nil {
		return vt.Content
	}
	return nil
}

type BetaCodeExecutionToolResultError struct {
	// Any of "invalid_tool_input", "unavailable", "too_many_requests",
	// "execution_time_exceeded".
	ErrorCode BetaCodeExecutionToolResultErrorCode  `json:"error_code" api:"required"`
	Type      constant.CodeExecutionToolResultError `json:"type" default:"code_execution_tool_result_error"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ErrorCode   respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaCodeExecutionToolResultError) RawJSON() string { return r.JSON.raw }
func (r *BetaCodeExecutionToolResultError) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaCodeExecutionToolResultErrorCode string

const (
	BetaCodeExecutionToolResultErrorCodeInvalidToolInput      BetaCodeExecutionToolResultErrorCode = "invalid_tool_input"
	BetaCodeExecutionToolResultErrorCodeUnavailable           BetaCodeExecutionToolResultErrorCode = "unavailable"
	BetaCodeExecutionToolResultErrorCodeTooManyRequests       BetaCodeExecutionToolResultErrorCode = "too_many_requests"
	BetaCodeExecutionToolResultErrorCodeExecutionTimeExceeded BetaCodeExecutionToolResultErrorCode = "execution_time_exceeded"
)

// The properties ErrorCode, Type are required.
type BetaCodeExecutionToolResultErrorParam struct {
	// Any of "invalid_tool_input", "unavailable", "too_many_requests",
	// "execution_time_exceeded".
	ErrorCode BetaCodeExecutionToolResultErrorCode `json:"error_code,omitzero" api:"required"`
	// This field can be elided, and will marshal its zero value as
	// "code_execution_tool_result_error".
	Type constant.CodeExecutionToolResultError `json:"type" default:"code_execution_tool_result_error"`
	paramObj
}

func (r BetaCodeExecutionToolResultErrorParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaCodeExecutionToolResultErrorParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaCodeExecutionToolResultErrorParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Automatically compact older context when reaching the configured trigger
// threshold.
//
// The property Type is required.
type BetaCompact20260112EditParam struct {
	// Additional instructions for summarization.
	Instructions param.Opt[string] `json:"instructions,omitzero"`
	// Whether to pause after compaction and return the compaction block to the user.
	PauseAfterCompaction param.Opt[bool] `json:"pause_after_compaction,omitzero"`
	// When to trigger compaction. Defaults to 150000 input tokens.
	Trigger BetaInputTokensTriggerParam `json:"trigger,omitzero"`
	// This field can be elided, and will marshal its zero value as "compact_20260112".
	Type constant.Compact20260112 `json:"type" default:"compact_20260112"`
	paramObj
}

func (r BetaCompact20260112EditParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaCompact20260112EditParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaCompact20260112EditParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// A compaction block returned when autocompact is triggered.
//
// When content is None, it indicates the compaction failed to produce a valid
// summary (e.g., malformed output from the model). Clients may round-trip
// compaction blocks with null content; the server treats them as no-ops.
type BetaCompactionBlock struct {
	// Summary of compacted content, or null if compaction failed
	Content string `json:"content" api:"required"`
	// Opaque metadata from prior compaction, to be round-tripped verbatim
	EncryptedContent string              `json:"encrypted_content" api:"required"`
	Type             constant.Compaction `json:"type" default:"compaction"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Content          respjson.Field
		EncryptedContent respjson.Field
		Type             respjson.Field
		ExtraFields      map[string]respjson.Field
		raw              string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaCompactionBlock) RawJSON() string { return r.JSON.raw }
func (r *BetaCompactionBlock) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// A compaction block containing summary of previous context.
//
// Users should round-trip these blocks from responses to subsequent requests to
// maintain context across compaction boundaries.
//
// When content is None, the block represents a failed compaction. The server
// treats these as no-ops. Empty string content is not allowed.
//
// The property Type is required.
type BetaCompactionBlockParam struct {
	// Summary of previously compacted content, or null if compaction failed
	Content param.Opt[string] `json:"content,omitzero"`
	// Opaque metadata from prior compaction, to be round-tripped verbatim
	EncryptedContent param.Opt[string] `json:"encrypted_content,omitzero"`
	// Create a cache control breakpoint at this content block.
	CacheControl BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	// This field can be elided, and will marshal its zero value as "compaction".
	Type constant.Compaction `json:"type" default:"compaction"`
	paramObj
}

func (r BetaCompactionBlockParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaCompactionBlockParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaCompactionBlockParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaCompactionContentBlockDelta struct {
	Content string `json:"content" api:"required"`
	// Opaque metadata from prior compaction, to be round-tripped verbatim
	EncryptedContent string                   `json:"encrypted_content" api:"required"`
	Type             constant.CompactionDelta `json:"type" default:"compaction_delta"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Content          respjson.Field
		EncryptedContent respjson.Field
		Type             respjson.Field
		ExtraFields      map[string]respjson.Field
		raw              string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaCompactionContentBlockDelta) RawJSON() string { return r.JSON.raw }
func (r *BetaCompactionContentBlockDelta) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Token usage for a compaction iteration.
type BetaCompactionIterationUsage struct {
	// Breakdown of cached tokens by TTL
	CacheCreation BetaCacheCreation `json:"cache_creation" api:"required"`
	// The number of input tokens used to create the cache entry.
	CacheCreationInputTokens int64 `json:"cache_creation_input_tokens" api:"required"`
	// The number of input tokens read from the cache.
	CacheReadInputTokens int64 `json:"cache_read_input_tokens" api:"required"`
	// The number of input tokens which were used.
	InputTokens int64 `json:"input_tokens" api:"required"`
	// The number of output tokens which were used.
	OutputTokens int64 `json:"output_tokens" api:"required"`
	// Usage for a compaction iteration
	Type constant.Compaction `json:"type" default:"compaction"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CacheCreation            respjson.Field
		CacheCreationInputTokens respjson.Field
		CacheReadInputTokens     respjson.Field
		InputTokens              respjson.Field
		OutputTokens             respjson.Field
		Type                     respjson.Field
		ExtraFields              map[string]respjson.Field
		raw                      string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaCompactionIterationUsage) RawJSON() string { return r.JSON.raw }
func (r *BetaCompactionIterationUsage) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `cursor_position`'s config overrides.
type BetaComputerCursorPositionConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaComputerCursorPositionConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaComputerCursorPositionConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaComputerCursorPositionConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `double_click`'s config overrides.
type BetaComputerDoubleClickConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaComputerDoubleClickConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaComputerDoubleClickConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaComputerDoubleClickConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `hold_key`'s config overrides.
type BetaComputerHoldKeyConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaComputerHoldKeyConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaComputerHoldKeyConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaComputerHoldKeyConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `key`'s config overrides.
type BetaComputerKeyConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaComputerKeyConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaComputerKeyConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaComputerKeyConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `left_click`'s config overrides.
type BetaComputerLeftClickConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaComputerLeftClickConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaComputerLeftClickConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaComputerLeftClickConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `left_click_drag`'s config overrides.
type BetaComputerLeftClickDragConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaComputerLeftClickDragConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaComputerLeftClickDragConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaComputerLeftClickDragConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `left_mouse_down`'s config overrides.
type BetaComputerLeftMouseDownConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaComputerLeftMouseDownConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaComputerLeftMouseDownConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaComputerLeftMouseDownConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `left_mouse_up`'s config overrides.
type BetaComputerLeftMouseUpConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaComputerLeftMouseUpConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaComputerLeftMouseUpConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaComputerLeftMouseUpConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `middle_click`'s config overrides.
type BetaComputerMiddleClickConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaComputerMiddleClickConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaComputerMiddleClickConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaComputerMiddleClickConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `mouse_move`'s config overrides.
type BetaComputerMouseMoveConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaComputerMouseMoveConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaComputerMouseMoveConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaComputerMouseMoveConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `right_click`'s config overrides.
type BetaComputerRightClickConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaComputerRightClickConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaComputerRightClickConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaComputerRightClickConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `screenshot`'s config overrides.
type BetaComputerScreenshotConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaComputerScreenshotConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaComputerScreenshotConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaComputerScreenshotConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `scroll`'s config overrides.
type BetaComputerScrollConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaComputerScrollConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaComputerScrollConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaComputerScrollConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The computer toolset: a single `tools[]` entry (carrying no `name`) that
// declares the computer tool family. The model is served the family's tool with
// any members disabled via `configs` removed from its schema. Every member is
// enabled by default, zoom included. The single-tool options `display_number` and
// `enable_zoom` are not fields of a toolset entry — it carries only `type`,
// `configs`, and `cache_control`; zoom is controlled via `configs.zoom.enabled`.
//
// The property Type is required.
type BetaComputerToolset20260801Param struct {
	// Create a cache control breakpoint at this content block.
	CacheControl BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	// Per-member configuration for `computer_toolset_20260801`: one optional field per
	// member tool, keyed by the member name — the same name the member's `tool_use`
	// blocks carry. Every member is an accepted key, and a member's defaults apply
	// wherever its key is absent. Unknown keys are rejected: the field set is this
	// toolset version's complete member set.
	Configs BetaComputerToolsetConfigsParam `json:"configs,omitzero"`
	// This field can be elided, and will marshal its zero value as
	// "computer_toolset_20260801".
	Type constant.ComputerToolset20260801 `json:"type" default:"computer_toolset_20260801"`
	paramObj
}

func (r BetaComputerToolset20260801Param) MarshalJSON() (data []byte, err error) {
	type shadow BetaComputerToolset20260801Param
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaComputerToolset20260801Param) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Per-member configuration for `computer_toolset_20260801`: one optional field per
// member tool, keyed by the member name — the same name the member's `tool_use`
// blocks carry. Every member is an accepted key, and a member's defaults apply
// wherever its key is absent. Unknown keys are rejected: the field set is this
// toolset version's complete member set.
type BetaComputerToolsetConfigsParam struct {
	// `cursor_position`'s config overrides.
	CursorPosition BetaComputerCursorPositionConfigParam `json:"cursor_position,omitzero"`
	// `double_click`'s config overrides.
	DoubleClick BetaComputerDoubleClickConfigParam `json:"double_click,omitzero"`
	// `hold_key`'s config overrides.
	HoldKey BetaComputerHoldKeyConfigParam `json:"hold_key,omitzero"`
	// `key`'s config overrides.
	Key BetaComputerKeyConfigParam `json:"key,omitzero"`
	// `left_click`'s config overrides.
	LeftClick BetaComputerLeftClickConfigParam `json:"left_click,omitzero"`
	// `left_click_drag`'s config overrides.
	LeftClickDrag BetaComputerLeftClickDragConfigParam `json:"left_click_drag,omitzero"`
	// `left_mouse_down`'s config overrides.
	LeftMouseDown BetaComputerLeftMouseDownConfigParam `json:"left_mouse_down,omitzero"`
	// `left_mouse_up`'s config overrides.
	LeftMouseUp BetaComputerLeftMouseUpConfigParam `json:"left_mouse_up,omitzero"`
	// `middle_click`'s config overrides.
	MiddleClick BetaComputerMiddleClickConfigParam `json:"middle_click,omitzero"`
	// `mouse_move`'s config overrides.
	MouseMove BetaComputerMouseMoveConfigParam `json:"mouse_move,omitzero"`
	// `right_click`'s config overrides.
	RightClick BetaComputerRightClickConfigParam `json:"right_click,omitzero"`
	// `screenshot`'s config overrides.
	Screenshot BetaComputerScreenshotConfigParam `json:"screenshot,omitzero"`
	// `scroll`'s config overrides.
	Scroll BetaComputerScrollConfigParam `json:"scroll,omitzero"`
	// `triple_click`'s config overrides.
	TripleClick BetaComputerTripleClickConfigParam `json:"triple_click,omitzero"`
	// `type`'s config overrides.
	Type BetaComputerTypeConfigParam `json:"type,omitzero"`
	// `wait`'s config overrides.
	Wait BetaComputerWaitConfigParam `json:"wait,omitzero"`
	// `zoom`'s config overrides.
	Zoom BetaComputerZoomConfigParam `json:"zoom,omitzero"`
	paramObj
}

func (r BetaComputerToolsetConfigsParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaComputerToolsetConfigsParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaComputerToolsetConfigsParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `triple_click`'s config overrides.
type BetaComputerTripleClickConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaComputerTripleClickConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaComputerTripleClickConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaComputerTripleClickConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `type`'s config overrides.
type BetaComputerTypeConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaComputerTypeConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaComputerTypeConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaComputerTypeConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `wait`'s config overrides.
type BetaComputerWaitConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaComputerWaitConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaComputerWaitConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaComputerWaitConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// `zoom`'s config overrides.
type BetaComputerZoomConfigParam struct {
	// Defer loading for this member. Must resolve to the same value on every enabled
	// member of the toolset.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether this member is offered to the model. Default is per member, per the
	// toolset's documentation. A member whose enabled resolves false is withheld from
	// the served schema.
	Enabled param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaComputerZoomConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaComputerZoomConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaComputerZoomConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Information about the container used in the request (for the code execution
// tool)
type BetaContainer struct {
	// Identifier for the container used in this request
	ID string `json:"id" api:"required"`
	// The time at which the container will expire.
	ExpiresAt time.Time `json:"expires_at" api:"required" format:"date-time"`
	// Skills loaded in the container
	Skills []BetaContainerSkill `json:"skills" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		ExpiresAt   respjson.Field
		Skills      respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaContainer) RawJSON() string { return r.JSON.raw }
func (r *BetaContainer) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Container parameters with skills to be loaded.
type BetaContainerParams struct {
	// Container id
	ID param.Opt[string] `json:"id,omitzero"`
	// List of skills to load in the container
	Skills []BetaSkillParams `json:"skills,omitzero"`
	paramObj
}

func (r BetaContainerParams) MarshalJSON() (data []byte, err error) {
	type shadow BetaContainerParams
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaContainerParams) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// A skill that was loaded in a container (response model).
type BetaContainerSkill struct {
	// Skill ID
	SkillID string `json:"skill_id" api:"required"`
	// Type of skill - either 'anthropic' (built-in) or 'custom' (user-defined)
	//
	// Any of "anthropic", "custom".
	Type BetaContainerSkillType `json:"type" api:"required"`
	// The resolved version: a skill version ID for custom skills.
	Version string `json:"version" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		SkillID     respjson.Field
		Type        respjson.Field
		Version     respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaContainerSkill) RawJSON() string { return r.JSON.raw }
func (r *BetaContainerSkill) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Type of skill - either 'anthropic' (built-in) or 'custom' (user-defined)
type BetaContainerSkillType string

const (
	BetaContainerSkillTypeAnthropic BetaContainerSkillType = "anthropic"
	BetaContainerSkillTypeCustom    BetaContainerSkillType = "custom"
)

// Response model for a file uploaded to the container.
type BetaContainerUploadBlock struct {
	FileID string                   `json:"file_id" api:"required"`
	Type   constant.ContainerUpload `json:"type" default:"container_upload"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		FileID      respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaContainerUploadBlock) RawJSON() string { return r.JSON.raw }
func (r *BetaContainerUploadBlock) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// A content block that represents a file to be uploaded to the container Files
// uploaded via this block will be available in the container's input directory.
//
// The properties FileID, Type are required.
type BetaContainerUploadBlockParam struct {
	FileID string `json:"file_id" api:"required"`
	// Create a cache control breakpoint at this content block.
	CacheControl BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	// This field can be elided, and will marshal its zero value as "container_upload".
	Type constant.ContainerUpload `json:"type" default:"container_upload"`
	paramObj
}

func (r BetaContainerUploadBlockParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaContainerUploadBlockParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaContainerUploadBlockParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// BetaContentBlockUnion contains all possible properties and values from
// [BetaTextBlock], [BetaThinkingBlock], [BetaRedactedThinkingBlock],
// [BetaToolUseBlock], [BetaServerToolUseBlock], [BetaWebSearchToolResultBlock],
// [BetaWebFetchToolResultBlock], [BetaAdvisorToolResultBlock],
// [BetaCodeExecutionToolResultBlock], [BetaBashCodeExecutionToolResultBlock],
// [BetaTextEditorCodeExecutionToolResultBlock], [BetaToolSearchToolResultBlock],
// [BetaMCPToolUseBlock], [BetaMCPToolResultBlock], [BetaContainerUploadBlock],
// [BetaCompactionBlock], [BetaFallbackBlock].
//
// Use the [BetaContentBlockUnion.AsAny] method to switch on the variant.
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
type BetaContentBlockUnion struct {
	// This field is from variant [BetaTextBlock].
	Citations []BetaTextCitationUnion `json:"citations"`
	// This field is from variant [BetaTextBlock].
	Text string `json:"text"`
	// Any of "text", "thinking", "redacted_thinking", "tool_use", "server_tool_use",
	// "web_search_tool_result", "web_fetch_tool_result", "advisor_tool_result",
	// "code_execution_tool_result", "bash_code_execution_tool_result",
	// "text_editor_code_execution_tool_result", "tool_search_tool_result",
	// "mcp_tool_use", "mcp_tool_result", "container_upload", "compaction", "fallback".
	Type string `json:"type"`
	// This field is from variant [BetaThinkingBlock].
	Signature string `json:"signature"`
	// This field is from variant [BetaThinkingBlock].
	Thinking string `json:"thinking"`
	// This field is from variant [BetaRedactedThinkingBlock].
	Data string `json:"data"`
	ID   string `json:"id"`
	// necessary custom code modification
	Input json.RawMessage `json:"input"`
	Name  string          `json:"name"`
	// This field is a union of [BetaToolUseBlockCallerUnion],
	// [BetaServerToolUseBlockCallerUnion], [BetaWebSearchToolResultBlockCallerUnion],
	// [BetaWebFetchToolResultBlockCallerUnion]
	Caller BetaContentBlockUnionCaller `json:"caller"`
	// This field is from variant [BetaToolUseBlock].
	ToolsetName string `json:"toolset_name"`
	// This field is a union of [BetaWebSearchToolResultBlockContentUnion],
	// [BetaWebFetchToolResultBlockContentUnion],
	// [BetaAdvisorToolResultBlockContentUnion],
	// [BetaCodeExecutionToolResultBlockContentUnion],
	// [BetaBashCodeExecutionToolResultBlockContentUnion],
	// [BetaTextEditorCodeExecutionToolResultBlockContentUnion],
	// [BetaToolSearchToolResultBlockContentUnion],
	// [BetaMCPToolResultBlockContentUnion], [string]
	Content   BetaContentBlockUnionContent `json:"content"`
	ToolUseID string                       `json:"tool_use_id"`
	// This field is from variant [BetaMCPToolUseBlock].
	ServerName string `json:"server_name"`
	// This field is from variant [BetaMCPToolResultBlock].
	IsError bool `json:"is_error"`
	// This field is from variant [BetaContainerUploadBlock].
	FileID string `json:"file_id"`
	// This field is from variant [BetaCompactionBlock].
	EncryptedContent string `json:"encrypted_content"`
	// This field is from variant [BetaFallbackBlock].
	From BetaFallbackInfo `json:"from"`
	// This field is from variant [BetaFallbackBlock].
	To BetaFallbackInfo `json:"to"`
	// This field is from variant [BetaFallbackBlock].
	Trigger BetaFallbackRefusalTrigger `json:"trigger"`
	JSON    struct {
		Citations        respjson.Field
		Text             respjson.Field
		Type             respjson.Field
		Signature        respjson.Field
		Thinking         respjson.Field
		Data             respjson.Field
		ID               respjson.Field
		Input            respjson.Field
		Name             respjson.Field
		Caller           respjson.Field
		ToolsetName      respjson.Field
		Content          respjson.Field
		ToolUseID        respjson.Field
		ServerName       respjson.Field
		IsError          respjson.Field
		FileID           respjson.Field
		EncryptedContent respjson.Field
		From             respjson.Field
		To               respjson.Field
		Trigger          respjson.Field
		raw              string
	} `json:"-"`
}

// anyBetaContentBlock is implemented by each variant of [BetaContentBlockUnion] to
// add type safety for the return type of [BetaContentBlockUnion.AsAny]
type anyBetaContentBlock interface {
	implBetaContentBlockUnion()
	toParamUnion() BetaContentBlockParamUnion
}

func (BetaTextBlock) implBetaContentBlockUnion()                              {}
func (BetaThinkingBlock) implBetaContentBlockUnion()                          {}
func (BetaRedactedThinkingBlock) implBetaContentBlockUnion()                  {}
func (BetaToolUseBlock) implBetaContentBlockUnion()                           {}
func (BetaServerToolUseBlock) implBetaContentBlockUnion()                     {}
func (BetaWebSearchToolResultBlock) implBetaContentBlockUnion()               {}
func (BetaWebFetchToolResultBlock) implBetaContentBlockUnion()                {}
func (BetaAdvisorToolResultBlock) implBetaContentBlockUnion()                 {}
func (BetaCodeExecutionToolResultBlock) implBetaContentBlockUnion()           {}
func (BetaBashCodeExecutionToolResultBlock) implBetaContentBlockUnion()       {}
func (BetaTextEditorCodeExecutionToolResultBlock) implBetaContentBlockUnion() {}
func (BetaToolSearchToolResultBlock) implBetaContentBlockUnion()              {}
func (BetaMCPToolUseBlock) implBetaContentBlockUnion()                        {}
func (BetaMCPToolResultBlock) implBetaContentBlockUnion()                     {}
func (BetaContainerUploadBlock) implBetaContentBlockUnion()                   {}
func (BetaCompactionBlock) implBetaContentBlockUnion()                        {}
func (BetaFallbackBlock) implBetaContentBlockUnion()                          {}

// Use the following switch statement to find the correct variant
//
//	switch variant := BetaContentBlockUnion.AsAny().(type) {
//	case anthropic.BetaTextBlock:
//	case anthropic.BetaThinkingBlock:
//	case anthropic.BetaRedactedThinkingBlock:
//	case anthropic.BetaToolUseBlock:
//	case anthropic.BetaServerToolUseBlock:
//	case anthropic.BetaWebSearchToolResultBlock:
//	case anthropic.BetaWebFetchToolResultBlock:
//	case anthropic.BetaAdvisorToolResultBlock:
//	case anthropic.BetaCodeExecutionToolResultBlock:
//	case anthropic.BetaBashCodeExecutionToolResultBlock:
//	case anthropic.BetaTextEditorCodeExecutionToolResultBlock:
//	case anthropic.BetaToolSearchToolResultBlock:
//	case anthropic.BetaMCPToolUseBlock:
//	case anthropic.BetaMCPToolResultBlock:
//	case anthropic.BetaContainerUploadBlock:
//	case anthropic.BetaCompactionBlock:
//	case anthropic.BetaFallbackBlock:
//	default:
//	  fmt.Errorf("no variant present")
//	}
func (u BetaContentBlockUnion) AsAny() anyBetaContentBlock {
	switch u.Type {
	case "text":
		return u.AsText()
	case "thinking":
		return u.AsThinking()
	case "redacted_thinking":
		return u.AsRedactedThinking()
	case "tool_use":
		return u.AsToolUse()
	case "server_tool_use":
		return u.AsServerToolUse()
	case "web_search_tool_result":
		return u.AsWebSearchToolResult()
	case "web_fetch_tool_result":
		return u.AsWebFetchToolResult()
	case "advisor_tool_result":
		return u.AsAdvisorToolResult()
	case "code_execution_tool_result":
		return u.AsCodeExecutionToolResult()
	case "bash_code_execution_tool_result":
		return u.AsBashCodeExecutionToolResult()
	case "text_editor_code_execution_tool_result":
		return u.AsTextEditorCodeExecutionToolResult()
	case "tool_search_tool_result":
		return u.AsToolSearchToolResult()
	case "mcp_tool_use":
		return u.AsMCPToolUse()
	case "mcp_tool_result":
		return u.AsMCPToolResult()
	case "container_upload":
		return u.AsContainerUpload()
	case "compaction":
		return u.AsCompaction()
	case "fallback":
		return u.AsFallback()
	}
	return nil
}

func (u BetaContentBlockUnion) AsText() (v BetaTextBlock) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaContentBlockUnion) AsThinking() (v BetaThinkingBlock) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaContentBlockUnion) AsRedactedThinking() (v BetaRedactedThinkingBlock) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaContentBlockUnion) AsToolUse() (v BetaToolUseBlock) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaContentBlockUnion) AsServerToolUse() (v BetaServerToolUseBlock) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaContentBlockUnion) AsWebSearchToolResult() (v BetaWebSearchToolResultBlock) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaContentBlockUnion) AsWebFetchToolResult() (v BetaWebFetchToolResultBlock) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaContentBlockUnion) AsAdvisorToolResult() (v BetaAdvisorToolResultBlock) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaContentBlockUnion) AsCodeExecutionToolResult() (v BetaCodeExecutionToolResultBlock) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaContentBlockUnion) AsBashCodeExecutionToolResult() (v BetaBashCodeExecutionToolResultBlock) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaContentBlockUnion) AsTextEditorCodeExecutionToolResult() (v BetaTextEditorCodeExecutionToolResultBlock) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaContentBlockUnion) AsToolSearchToolResult() (v BetaToolSearchToolResultBlock) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaContentBlockUnion) AsMCPToolUse() (v BetaMCPToolUseBlock) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaContentBlockUnion) AsMCPToolResult() (v BetaMCPToolResultBlock) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaContentBlockUnion) AsContainerUpload() (v BetaContainerUploadBlock) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaContentBlockUnion) AsCompaction() (v BetaCompactionBlock) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaContentBlockUnion) AsFallback() (v BetaFallbackBlock) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u BetaContentBlockUnion) RawJSON() string { return u.JSON.raw }

func (r *BetaContentBlockUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// BetaContentBlockUnionCaller is an implicit subunion of [BetaContentBlockUnion].
// BetaContentBlockUnionCaller provides convenient access to the sub-properties of
// the union.
//
// For type safety it is recommended to directly use a variant of the
// [BetaContentBlockUnion].
type BetaContentBlockUnionCaller struct {
	Type   string `json:"type"`
	ToolID string `json:"tool_id"`
	JSON   struct {
		Type   respjson.Field
		ToolID respjson.Field
		raw    string
	} `json:"-"`
}

func (r *BetaContentBlockUnionCaller) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// BetaContentBlockUnionContent is an implicit subunion of [BetaContentBlockUnion].
// BetaContentBlockUnionContent provides convenient access to the sub-properties of
// the union.
//
// For type safety it is recommended to directly use a variant of the
// [BetaContentBlockUnion].
//
// If the underlying value is not a json object, one of the following properties
// will be valid: OfBetaWebSearchResultBlockArray OfString
// OfBetaMCPToolResultBlockContent]
type BetaContentBlockUnionContent struct {
	// This field will be present if the value is a [[]BetaWebSearchResultBlock]
	// instead of an object.
	OfBetaWebSearchResultBlockArray []BetaWebSearchResultBlock `json:",inline"`
	// This field will be present if the value is a [string] instead of an object.
	OfString string `json:",inline"`
	// This field will be present if the value is a [[]BetaTextBlock] instead of an
	// object.
	OfBetaMCPToolResultBlockContent []BetaTextBlock `json:",inline"`
	ErrorCode                       string          `json:"error_code"`
	Type                            string          `json:"type"`
	// This field is a union of [BetaDocumentBlock], [[]BetaCodeExecutionOutputBlock],
	// [[]BetaCodeExecutionOutputBlock], [[]BetaBashCodeExecutionOutputBlock], [string]
	Content BetaContentBlockUnionContentContent `json:"content"`
	// This field is from variant [BetaWebFetchToolResultBlockContentUnion].
	RetrievedAt string `json:"retrieved_at"`
	// This field is from variant [BetaWebFetchToolResultBlockContentUnion].
	URL        string `json:"url"`
	StopReason string `json:"stop_reason"`
	// This field is from variant [BetaAdvisorToolResultBlockContentUnion].
	Text string `json:"text"`
	// This field is from variant [BetaAdvisorToolResultBlockContentUnion].
	EncryptedContent string `json:"encrypted_content"`
	ReturnCode       int64  `json:"return_code"`
	Stderr           string `json:"stderr"`
	Stdout           string `json:"stdout"`
	// This field is from variant [BetaCodeExecutionToolResultBlockContentUnion].
	EncryptedStdout string `json:"encrypted_stdout"`
	ErrorMessage    string `json:"error_message"`
	// This field is from variant
	// [BetaTextEditorCodeExecutionToolResultBlockContentUnion].
	FileType BetaTextEditorCodeExecutionViewResultBlockFileType `json:"file_type"`
	// This field is from variant
	// [BetaTextEditorCodeExecutionToolResultBlockContentUnion].
	NumLines int64 `json:"num_lines"`
	// This field is from variant
	// [BetaTextEditorCodeExecutionToolResultBlockContentUnion].
	StartLine int64 `json:"start_line"`
	// This field is from variant
	// [BetaTextEditorCodeExecutionToolResultBlockContentUnion].
	TotalLines int64 `json:"total_lines"`
	// This field is from variant
	// [BetaTextEditorCodeExecutionToolResultBlockContentUnion].
	IsFileUpdate bool `json:"is_file_update"`
	// This field is from variant
	// [BetaTextEditorCodeExecutionToolResultBlockContentUnion].
	Lines []string `json:"lines"`
	// This field is from variant
	// [BetaTextEditorCodeExecutionToolResultBlockContentUnion].
	NewLines int64 `json:"new_lines"`
	// This field is from variant
	// [BetaTextEditorCodeExecutionToolResultBlockContentUnion].
	NewStart int64 `json:"new_start"`
	// This field is from variant
	// [BetaTextEditorCodeExecutionToolResultBlockContentUnion].
	OldLines int64 `json:"old_lines"`
	// This field is from variant
	// [BetaTextEditorCodeExecutionToolResultBlockContentUnion].
	OldStart int64 `json:"old_start"`
	// This field is from variant [BetaToolSearchToolResultBlockContentUnion].
	ToolReferences []BetaToolReferenceBlock `json:"tool_references"`
	JSON           struct {
		OfBetaWebSearchResultBlockArray respjson.Field
		OfString                        respjson.Field
		OfBetaMCPToolResultBlockContent respjson.Field
		ErrorCode                       respjson.Field
		Type                            respjson.Field
		Content                         respjson.Field
		RetrievedAt                     respjson.Field
		URL                             respjson.Field
		StopReason                      respjson.Field
		Text                            respjson.Field
		EncryptedContent                respjson.Field
		ReturnCode                      respjson.Field
		Stderr                          respjson.Field
		Stdout                          respjson.Field
		EncryptedStdout                 respjson.Field
		ErrorMessage                    respjson.Field
		FileType                        respjson.Field
		NumLines                        respjson.Field
		StartLine                       respjson.Field
		TotalLines                      respjson.Field
		IsFileUpdate                    respjson.Field
		Lines                           respjson.Field
		NewLines                        respjson.Field
		NewStart                        respjson.Field
		OldLines                        respjson.Field
		OldStart                        respjson.Field
		ToolReferences                  respjson.Field
		raw                             string
	} `json:"-"`
}

func (r *BetaContentBlockUnionContent) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// BetaContentBlockUnionContentContent is an implicit subunion of
// [BetaContentBlockUnion]. BetaContentBlockUnionContentContent provides convenient
// access to the sub-properties of the union.
//
// For type safety it is recommended to directly use a variant of the
// [BetaContentBlockUnion].
//
// If the underlying value is not a json object, one of the following properties
// will be valid: OfContent OfString]
type BetaContentBlockUnionContentContent struct {
	// This field will be present if the value is a [[]BetaCodeExecutionOutputBlock]
	// instead of an object.
	OfContent []BetaCodeExecutionOutputBlock `json:",inline"`
	// This field will be present if the value is a [string] instead of an object.
	OfString string `json:",inline"`
	// This field is from variant [BetaDocumentBlock].
	Citations BetaCitationConfig `json:"citations"`
	// This field is from variant [BetaDocumentBlock].
	Source BetaDocumentBlockSourceUnion `json:"source"`
	// This field is from variant [BetaDocumentBlock].
	Title string `json:"title"`
	// This field is from variant [BetaDocumentBlock].
	Type constant.Document `json:"type"`
	JSON struct {
		OfContent respjson.Field
		OfString  respjson.Field
		Citations respjson.Field
		Source    respjson.Field
		Title     respjson.Field
		Type      respjson.Field
		raw       string
	} `json:"-"`
}

func (r *BetaContentBlockUnionContentContent) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

func NewBetaTextBlock(text string) BetaContentBlockParamUnion {
	var variant BetaTextBlockParam
	variant.Text = text
	return BetaContentBlockParamUnion{OfText: &variant}
}

func NewBetaImageBlock[
	T BetaBase64ImageSourceParam | BetaURLImageSourceParam | BetaFileImageSourceParam,
](source T) BetaContentBlockParamUnion {
	var image BetaImageBlockParam
	switch v := any(source).(type) {
	case BetaBase64ImageSourceParam:
		image.Source.OfBase64 = &v
	case BetaURLImageSourceParam:
		image.Source.OfURL = &v
	case BetaFileImageSourceParam:
		image.Source.OfFile = &v
	}
	return BetaContentBlockParamUnion{OfImage: &image}
}

func NewBetaDocumentBlock[
	T BetaBase64PDFSourceParam | BetaPlainTextSourceParam | BetaContentBlockSourceParam | BetaURLPDFSourceParam | BetaFileDocumentSourceParam,
](source T) BetaContentBlockParamUnion {
	var document BetaRequestDocumentBlockParam
	switch v := any(source).(type) {
	case BetaBase64PDFSourceParam:
		document.Source.OfBase64 = &v
	case BetaPlainTextSourceParam:
		document.Source.OfText = &v
	case BetaContentBlockSourceParam:
		document.Source.OfContent = &v
	case BetaURLPDFSourceParam:
		document.Source.OfURL = &v
	case BetaFileDocumentSourceParam:
		document.Source.OfFile = &v
	}
	return BetaContentBlockParamUnion{OfDocument: &document}
}

func NewBetaSearchResultBlock(content []BetaTextBlockParam, source string, title string) BetaContentBlockParamUnion {
	var searchResult BetaSearchResultBlockParam
	searchResult.Content = content
	searchResult.Source = source
	searchResult.Title = title
	return BetaContentBlockParamUnion{OfSearchResult: &searchResult}
}

func NewBetaThinkingBlock(signature string, thinking string) BetaContentBlockParamUnion {
	var variant BetaThinkingBlockParam
	variant.Signature = signature
	variant.Thinking = thinking
	return BetaContentBlockParamUnion{OfThinking: &variant}
}

func NewBetaRedactedThinkingBlock(data string) BetaContentBlockParamUnion {
	var redactedThinking BetaRedactedThinkingBlockParam
	redactedThinking.Data = data
	return BetaContentBlockParamUnion{OfRedactedThinking: &redactedThinking}
}

func NewBetaToolUseBlock(id string, input any, name string) BetaContentBlockParamUnion {
	var toolUse BetaToolUseBlockParam
	toolUse.ID = id
	toolUse.Input = input
	toolUse.Name = name
	return BetaContentBlockParamUnion{OfToolUse: &toolUse}
}

func NewBetaToolResultBlock(toolUseID string, content string, isError bool) BetaContentBlockParamUnion {
	var toolBlock BetaToolResultBlockParam
	toolBlock.ToolUseID = toolUseID
	toolBlock.Content = []BetaToolResultBlockParamContentUnion{
		{OfText: &BetaTextBlockParam{Text: content}},
	}
	toolBlock.IsError = Bool(isError)
	return BetaContentBlockParamUnion{OfToolResult: &toolBlock}
}

func NewBetaServerToolUseBlock(id string, input any, name BetaServerToolUseBlockParamName) BetaContentBlockParamUnion {
	var serverToolUse BetaServerToolUseBlockParam
	serverToolUse.ID = id
	serverToolUse.Input = input
	serverToolUse.Name = name
	return BetaContentBlockParamUnion{OfServerToolUse: &serverToolUse}
}

func NewBetaWebSearchToolResultBlock[
	T []BetaWebSearchResultBlockParam | BetaWebSearchToolRequestErrorParam,
](content T, toolUseID string) BetaContentBlockParamUnion {
	var webSearchToolResult BetaWebSearchToolResultBlockParam
	switch v := any(content).(type) {
	case []BetaWebSearchResultBlockParam:
		webSearchToolResult.Content.OfResultBlock = v
	case BetaWebSearchToolRequestErrorParam:
		webSearchToolResult.Content.OfError = &v
	}
	webSearchToolResult.ToolUseID = toolUseID
	return BetaContentBlockParamUnion{OfWebSearchToolResult: &webSearchToolResult}
}

func NewBetaWebFetchToolResultBlock[
	T BetaWebFetchToolResultErrorBlockParam | BetaWebFetchBlockParam,
](content T, toolUseID string) BetaContentBlockParamUnion {
	var webFetchToolResult BetaWebFetchToolResultBlockParam
	switch v := any(content).(type) {
	case BetaWebFetchToolResultErrorBlockParam:
		webFetchToolResult.Content.OfRequestWebFetchToolResultError = &v
	case BetaWebFetchBlockParam:
		webFetchToolResult.Content.OfRequestWebFetchResultBlock = &v
	}
	webFetchToolResult.ToolUseID = toolUseID
	return BetaContentBlockParamUnion{OfWebFetchToolResult: &webFetchToolResult}
}

func NewBetaAdvisorToolResultBlock[
	T BetaAdvisorToolResultErrorParam | BetaAdvisorResultBlockParam | BetaAdvisorRedactedResultBlockParam,
](content T, toolUseID string) BetaContentBlockParamUnion {
	var advisorToolResult BetaAdvisorToolResultBlockParam
	switch v := any(content).(type) {
	case BetaAdvisorToolResultErrorParam:
		advisorToolResult.Content.OfRequestAdvisorToolResultError = &v
	case BetaAdvisorResultBlockParam:
		advisorToolResult.Content.OfRequestAdvisorResultBlock = &v
	case BetaAdvisorRedactedResultBlockParam:
		advisorToolResult.Content.OfRequestAdvisorRedactedResultBlock = &v
	}
	advisorToolResult.ToolUseID = toolUseID
	return BetaContentBlockParamUnion{OfAdvisorToolResult: &advisorToolResult}
}

func NewBetaCodeExecutionToolResultBlock[
	T BetaCodeExecutionToolResultErrorParam | BetaCodeExecutionResultBlockParam | BetaEncryptedCodeExecutionResultBlockParam,
](content T, toolUseID string) BetaContentBlockParamUnion {
	var codeExecutionToolResult BetaCodeExecutionToolResultBlockParam
	switch v := any(content).(type) {
	case BetaCodeExecutionToolResultErrorParam:
		codeExecutionToolResult.Content.OfError = &v
	case BetaCodeExecutionResultBlockParam:
		codeExecutionToolResult.Content.OfResultBlock = &v
	case BetaEncryptedCodeExecutionResultBlockParam:
		codeExecutionToolResult.Content.OfRequestEncryptedCodeExecutionResultBlock = &v
	}
	codeExecutionToolResult.ToolUseID = toolUseID
	return BetaContentBlockParamUnion{OfCodeExecutionToolResult: &codeExecutionToolResult}
}

func NewBetaBashCodeExecutionToolResultBlock[
	T BetaBashCodeExecutionToolResultErrorParam | BetaBashCodeExecutionResultBlockParam,
](content T, toolUseID string) BetaContentBlockParamUnion {
	var bashCodeExecutionToolResult BetaBashCodeExecutionToolResultBlockParam
	switch v := any(content).(type) {
	case BetaBashCodeExecutionToolResultErrorParam:
		bashCodeExecutionToolResult.Content.OfRequestBashCodeExecutionToolResultError = &v
	case BetaBashCodeExecutionResultBlockParam:
		bashCodeExecutionToolResult.Content.OfRequestBashCodeExecutionResultBlock = &v
	}
	bashCodeExecutionToolResult.ToolUseID = toolUseID
	return BetaContentBlockParamUnion{OfBashCodeExecutionToolResult: &bashCodeExecutionToolResult}
}

func NewBetaTextEditorCodeExecutionToolResultBlock[
	T BetaTextEditorCodeExecutionToolResultErrorParam | BetaTextEditorCodeExecutionViewResultBlockParam | BetaTextEditorCodeExecutionCreateResultBlockParam | BetaTextEditorCodeExecutionStrReplaceResultBlockParam,
](content T, toolUseID string) BetaContentBlockParamUnion {
	var textEditorCodeExecutionToolResult BetaTextEditorCodeExecutionToolResultBlockParam
	switch v := any(content).(type) {
	case BetaTextEditorCodeExecutionToolResultErrorParam:
		textEditorCodeExecutionToolResult.Content.OfRequestTextEditorCodeExecutionToolResultError = &v
	case BetaTextEditorCodeExecutionViewResultBlockParam:
		textEditorCodeExecutionToolResult.Content.OfRequestTextEditorCodeExecutionViewResultBlock = &v
	case BetaTextEditorCodeExecutionCreateResultBlockParam:
		textEditorCodeExecutionToolResult.Content.OfRequestTextEditorCodeExecutionCreateResultBlock = &v
	case BetaTextEditorCodeExecutionStrReplaceResultBlockParam:
		textEditorCodeExecutionToolResult.Content.OfRequestTextEditorCodeExecutionStrReplaceResultBlock = &v
	}
	textEditorCodeExecutionToolResult.ToolUseID = toolUseID
	return BetaContentBlockParamUnion{OfTextEditorCodeExecutionToolResult: &textEditorCodeExecutionToolResult}
}

func NewBetaToolSearchToolResultBlock[
	T BetaToolSearchToolResultErrorParam | BetaToolSearchToolSearchResultBlockParam,
](content T, toolUseID string) BetaContentBlockParamUnion {
	var toolSearchToolResult BetaToolSearchToolResultBlockParam
	switch v := any(content).(type) {
	case BetaToolSearchToolResultErrorParam:
		toolSearchToolResult.Content.OfRequestToolSearchToolResultError = &v
	case BetaToolSearchToolSearchResultBlockParam:
		toolSearchToolResult.Content.OfRequestToolSearchToolSearchResultBlock = &v
	}
	toolSearchToolResult.ToolUseID = toolUseID
	return BetaContentBlockParamUnion{OfToolSearchToolResult: &toolSearchToolResult}
}

func NewBetaMCPToolResultBlock(toolUseID string) BetaContentBlockParamUnion {
	var mcpToolResult BetaRequestMCPToolResultBlockParam
	mcpToolResult.ToolUseID = toolUseID
	return BetaContentBlockParamUnion{OfMCPToolResult: &mcpToolResult}
}

func NewBetaContainerUploadBlock(fileID string) BetaContentBlockParamUnion {
	var containerUpload BetaContainerUploadBlockParam
	containerUpload.FileID = fileID
	return BetaContentBlockParamUnion{OfContainerUpload: &containerUpload}
}

func NewBetaToolAdditionBlock[
	T BetaToolChangeToolReferenceParam | BetaToolChangeMCPToolReferenceParam | BetaToolChangeMCPToolsetReferenceParam,
](tool T) BetaContentBlockParamUnion {
	var toolAddition BetaRequestToolAdditionBlockParam
	switch v := any(tool).(type) {
	case BetaToolChangeToolReferenceParam:
		toolAddition.Tool.OfToolReference = &v
	case BetaToolChangeMCPToolReferenceParam:
		toolAddition.Tool.OfMCPToolReference = &v
	case BetaToolChangeMCPToolsetReferenceParam:
		toolAddition.Tool.OfMCPToolsetReference = &v
	}
	return BetaContentBlockParamUnion{OfToolAddition: &toolAddition}
}

func NewBetaToolRemovalBlock[
	T BetaToolChangeToolReferenceParam | BetaToolChangeMCPToolReferenceParam | BetaToolChangeMCPToolsetReferenceParam,
](tool T) BetaContentBlockParamUnion {
	var toolRemoval BetaRequestToolRemovalBlockParam
	switch v := any(tool).(type) {
	case BetaToolChangeToolReferenceParam:
		toolRemoval.Tool.OfToolReference = &v
	case BetaToolChangeMCPToolReferenceParam:
		toolRemoval.Tool.OfMCPToolReference = &v
	case BetaToolChangeMCPToolsetReferenceParam:
		toolRemoval.Tool.OfMCPToolsetReference = &v
	}
	return BetaContentBlockParamUnion{OfToolRemoval: &toolRemoval}
}

func NewBetaFallbackBlock(from BetaFallbackInfoParam, to BetaFallbackInfoParam) BetaContentBlockParamUnion {
	var fallback BetaFallbackBlockParam
	fallback.From = from
	fallback.To = to
	return BetaContentBlockParamUnion{OfFallback: &fallback}
}

// Only one field can be non-zero.
//
// Use [param.IsOmitted] to confirm if a field is set.
type BetaContentBlockParamUnion struct {
	OfText                              *BetaTextBlockParam                              `json:",omitzero,inline"`
	OfImage                             *BetaImageBlockParam                             `json:",omitzero,inline"`
	OfDocument                          *BetaRequestDocumentBlockParam                   `json:",omitzero,inline"`
	OfSearchResult                      *BetaSearchResultBlockParam                      `json:",omitzero,inline"`
	OfThinking                          *BetaThinkingBlockParam                          `json:",omitzero,inline"`
	OfRedactedThinking                  *BetaRedactedThinkingBlockParam                  `json:",omitzero,inline"`
	OfToolUse                           *BetaToolUseBlockParam                           `json:",omitzero,inline"`
	OfToolResult                        *BetaToolResultBlockParam                        `json:",omitzero,inline"`
	OfServerToolUse                     *BetaServerToolUseBlockParam                     `json:",omitzero,inline"`
	OfWebSearchToolResult               *BetaWebSearchToolResultBlockParam               `json:",omitzero,inline"`
	OfWebFetchToolResult                *BetaWebFetchToolResultBlockParam                `json:",omitzero,inline"`
	OfAdvisorToolResult                 *BetaAdvisorToolResultBlockParam                 `json:",omitzero,inline"`
	OfCodeExecutionToolResult           *BetaCodeExecutionToolResultBlockParam           `json:",omitzero,inline"`
	OfBashCodeExecutionToolResult       *BetaBashCodeExecutionToolResultBlockParam       `json:",omitzero,inline"`
	OfTextEditorCodeExecutionToolResult *BetaTextEditorCodeExecutionToolResultBlockParam `json:",omitzero,inline"`
	OfToolSearchToolResult              *BetaToolSearchToolResultBlockParam              `json:",omitzero,inline"`
	OfMCPToolUse                        *BetaMCPToolUseBlockParam                        `json:",omitzero,inline"`
	OfMCPToolResult                     *BetaRequestMCPToolResultBlockParam              `json:",omitzero,inline"`
	OfContainerUpload                   *BetaContainerUploadBlockParam                   `json:",omitzero,inline"`
	OfCompaction                        *BetaCompactionBlockParam                        `json:",omitzero,inline"`
	OfToolAddition                      *BetaRequestToolAdditionBlockParam               `json:",omitzero,inline"`
	OfToolRemoval                       *BetaRequestToolRemovalBlockParam                `json:",omitzero,inline"`
	OfFallback                          *BetaFallbackBlockParam                          `json:",omitzero,inline"`
	paramUnion
}

func (u BetaContentBlockParamUnion) MarshalJSON() ([]byte, error) {
	return param.MarshalUnion(u, u.OfText,
		u.OfImage,
		u.OfDocument,
		u.OfSearchResult,
		u.OfThinking,
		u.OfRedactedThinking,
		u.OfToolUse,
		u.OfToolResult,
		u.OfServerToolUse,
		u.OfWebSearchToolResult,
		u.OfWebFetchToolResult,
		u.OfAdvisorToolResult,
		u.OfCodeExecutionToolResult,
		u.OfBashCodeExecutionToolResult,
		u.OfTextEditorCodeExecutionToolResult,
		u.OfToolSearchToolResult,
		u.OfMCPToolUse,
		u.OfMCPToolResult,
		u.OfContainerUpload,
		u.OfCompaction,
		u.OfToolAddition,
		u.OfToolRemoval,
		u.OfFallback)
}
func (u *BetaContentBlockParamUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, u)
}

func (u *BetaContentBlockParamUnion) asAny() any {
	if !param.IsOmitted(u.OfText) {
		return u.OfText
	} else if !param.IsOmitted(u.OfImage) {
		return u.OfImage
	} else if !param.IsOmitted(u.OfDocument) {
		return u.OfDocument
	} else if !param.IsOmitted(u.OfSearchResult) {
		return u.OfSearchResult
	} else if !param.IsOmitted(u.OfThinking) {
		return u.OfThinking
	} else if !param.IsOmitted(u.OfRedactedThinking) {
		return u.OfRedactedThinking
	} else if !param.IsOmitted(u.OfToolUse) {
		return u.OfToolUse
	} else if !param.IsOmitted(u.OfToolResult) {
		return u.OfToolResult
	} else if !param.IsOmitted(u.OfServerToolUse) {
		return u.OfServerToolUse
	} else if !param.IsOmitted(u.OfWebSearchToolResult) {
		return u.OfWebSearchToolResult
	} else if !param.IsOmitted(u.OfWebFetchToolResult) {
		return u.OfWebFetchToolResult
	} else if !param.IsOmitted(u.OfAdvisorToolResult) {
		return u.OfAdvisorToolResult
	} else if !param.IsOmitted(u.OfCodeExecutionToolResult) {
		return u.OfCodeExecutionToolResult
	} else if !param.IsOmitted(u.OfBashCodeExecutionToolResult) {
		return u.OfBashCodeExecutionToolResult
	} else if !param.IsOmitted(u.OfTextEditorCodeExecutionToolResult) {
		return u.OfTextEditorCodeExecutionToolResult
	} else if !param.IsOmitted(u.OfToolSearchToolResult) {
		return u.OfToolSearchToolResult
	} else if !param.IsOmitted(u.OfMCPToolUse) {
		return u.OfMCPToolUse
	} else if !param.IsOmitted(u.OfMCPToolResult) {
		return u.OfMCPToolResult
	} else if !param.IsOmitted(u.OfContainerUpload) {
		return u.OfContainerUpload
	} else if !param.IsOmitted(u.OfCompaction) {
		return u.OfCompaction
	} else if !param.IsOmitted(u.OfToolAddition) {
		return u.OfToolAddition
	} else if !param.IsOmitted(u.OfToolRemoval) {
		return u.OfToolRemoval
	} else if !param.IsOmitted(u.OfFallback) {
		return u.OfFallback
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaContentBlockParamUnion) GetText() *string {
	if vt := u.OfText; vt != nil {
		return &vt.Text
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaContentBlockParamUnion) GetTransformations() *BetaImageTransformationsParam {
	if vt := u.OfImage; vt != nil {
		return &vt.Transformations
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaContentBlockParamUnion) GetContext() *string {
	if vt := u.OfDocument; vt != nil && vt.Context.Valid() {
		return &vt.Context.Value
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaContentBlockParamUnion) GetSignature() *string {
	if vt := u.OfThinking; vt != nil {
		return &vt.Signature
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaContentBlockParamUnion) GetThinking() *string {
	if vt := u.OfThinking; vt != nil {
		return &vt.Thinking
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaContentBlockParamUnion) GetData() *string {
	if vt := u.OfRedactedThinking; vt != nil {
		return &vt.Data
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaContentBlockParamUnion) GetServerName() *string {
	if vt := u.OfMCPToolUse; vt != nil {
		return &vt.ServerName
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaContentBlockParamUnion) GetFileID() *string {
	if vt := u.OfContainerUpload; vt != nil {
		return &vt.FileID
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaContentBlockParamUnion) GetEncryptedContent() *string {
	if vt := u.OfCompaction; vt != nil && vt.EncryptedContent.Valid() {
		return &vt.EncryptedContent.Value
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaContentBlockParamUnion) GetFrom() *BetaFallbackInfoParam {
	if vt := u.OfFallback; vt != nil {
		return &vt.From
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaContentBlockParamUnion) GetTo() *BetaFallbackInfoParam {
	if vt := u.OfFallback; vt != nil {
		return &vt.To
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaContentBlockParamUnion) GetTrigger() *any {
	if vt := u.OfFallback; vt != nil {
		return &vt.Trigger
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaContentBlockParamUnion) GetType() *string {
	if vt := u.OfText; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfImage; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfDocument; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfSearchResult; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfThinking; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfRedactedThinking; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfToolUse; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfToolResult; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfServerToolUse; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfWebSearchToolResult; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfWebFetchToolResult; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfAdvisorToolResult; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfCodeExecutionToolResult; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfBashCodeExecutionToolResult; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfTextEditorCodeExecutionToolResult; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfToolSearchToolResult; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfMCPToolUse; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfMCPToolResult; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfContainerUpload; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfCompaction; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfToolAddition; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfToolRemoval; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfFallback; vt != nil {
		return (*string)(&vt.Type)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaContentBlockParamUnion) GetTitle() *string {
	if vt := u.OfDocument; vt != nil && vt.Title.Valid() {
		return &vt.Title.Value
	} else if vt := u.OfSearchResult; vt != nil {
		return (*string)(&vt.Title)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaContentBlockParamUnion) GetID() *string {
	if vt := u.OfToolUse; vt != nil {
		return (*string)(&vt.ID)
	} else if vt := u.OfServerToolUse; vt != nil {
		return (*string)(&vt.ID)
	} else if vt := u.OfMCPToolUse; vt != nil {
		return (*string)(&vt.ID)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaContentBlockParamUnion) GetName() *string {
	if vt := u.OfToolUse; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfServerToolUse; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfMCPToolUse; vt != nil {
		return (*string)(&vt.Name)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaContentBlockParamUnion) GetToolsetName() *string {
	if vt := u.OfToolUse; vt != nil && vt.ToolsetName.Valid() {
		return &vt.ToolsetName.Value
	} else if vt := u.OfToolResult; vt != nil && vt.ToolsetName.Valid() {
		return &vt.ToolsetName.Value
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaContentBlockParamUnion) GetToolUseID() *string {
	if vt := u.OfToolResult; vt != nil {
		return (*string)(&vt.ToolUseID)
	} else if vt := u.OfWebSearchToolResult; vt != nil {
		return (*string)(&vt.ToolUseID)
	} else if vt := u.OfWebFetchToolResult; vt != nil {
		return (*string)(&vt.ToolUseID)
	} else if vt := u.OfAdvisorToolResult; vt != nil {
		return (*string)(&vt.ToolUseID)
	} else if vt := u.OfCodeExecutionToolResult; vt != nil {
		return (*string)(&vt.ToolUseID)
	} else if vt := u.OfBashCodeExecutionToolResult; vt != nil {
		return (*string)(&vt.ToolUseID)
	} else if vt := u.OfTextEditorCodeExecutionToolResult; vt != nil {
		return (*string)(&vt.ToolUseID)
	} else if vt := u.OfToolSearchToolResult; vt != nil {
		return (*string)(&vt.ToolUseID)
	} else if vt := u.OfMCPToolResult; vt != nil {
		return (*string)(&vt.ToolUseID)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaContentBlockParamUnion) GetIsError() *bool {
	if vt := u.OfToolResult; vt != nil && vt.IsError.Valid() {
		return &vt.IsError.Value
	} else if vt := u.OfMCPToolResult; vt != nil && vt.IsError.Valid() {
		return &vt.IsError.Value
	}
	return nil
}

// Returns a pointer to the underlying variant's CacheControl property, if present.
func (u BetaContentBlockParamUnion) GetCacheControl() *BetaCacheControlEphemeralParam {
	if vt := u.OfText; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfImage; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfDocument; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfSearchResult; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfToolUse; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfToolResult; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfServerToolUse; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfWebSearchToolResult; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfWebFetchToolResult; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfAdvisorToolResult; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfCodeExecutionToolResult; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfBashCodeExecutionToolResult; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfTextEditorCodeExecutionToolResult; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfToolSearchToolResult; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfMCPToolUse; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfMCPToolResult; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfContainerUpload; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfCompaction; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfToolAddition; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfToolRemoval; vt != nil {
		return &vt.CacheControl
	}
	return nil
}

// Returns a subunion which exports methods to access subproperties
//
// Or use AsAny() to get the underlying value
func (u BetaContentBlockParamUnion) GetCitations() (res betaContentBlockParamUnionCitations) {
	if vt := u.OfText; vt != nil {
		res.any = &vt.Citations
	} else if vt := u.OfDocument; vt != nil {
		res.any = &vt.Citations
	} else if vt := u.OfSearchResult; vt != nil {
		res.any = &vt.Citations
	}
	return
}

// Can have the runtime types [*[]BetaTextCitationParamUnion],
// [*BetaCitationsConfigParam]
type betaContentBlockParamUnionCitations struct{ any }

// Use the following switch statement to get the type of the union:
//
//	switch u.AsAny().(type) {
//	case *[]anthropic.BetaTextCitationParamUnion:
//	case *anthropic.BetaCitationsConfigParam:
//	default:
//	    fmt.Errorf("not present")
//	}
func (u betaContentBlockParamUnionCitations) AsAny() any { return u.any }

// Returns a pointer to the underlying variant's property, if present.
func (u betaContentBlockParamUnionCitations) GetEnabled() *bool {
	switch vt := u.any.(type) {
	case *BetaCitationsConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	}
	return nil
}

// Returns a subunion which exports methods to access subproperties
//
// Or use AsAny() to get the underlying value
func (u BetaContentBlockParamUnion) GetSource() (res betaContentBlockParamUnionSource) {
	if vt := u.OfImage; vt != nil {
		res.any = vt.Source.asAny()
	} else if vt := u.OfDocument; vt != nil {
		res.any = vt.Source.asAny()
	} else if vt := u.OfSearchResult; vt != nil {
		res.any = &vt.Source
	}
	return
}

// Can have the runtime types [*BetaBase64ImageSourceParam],
// [*BetaURLImageSourceParam], [*BetaFileImageSourceParam],
// [*BetaBase64PDFSourceParam], [*BetaPlainTextSourceParam],
// [*BetaContentBlockSourceParam], [*BetaURLPDFSourceParam],
// [*BetaFileDocumentSourceParam], [*string]
type betaContentBlockParamUnionSource struct{ any }

// Use the following switch statement to get the type of the union:
//
//	switch u.AsAny().(type) {
//	case *anthropic.BetaBase64ImageSourceParam:
//	case *anthropic.BetaURLImageSourceParam:
//	case *anthropic.BetaFileImageSourceParam:
//	case *anthropic.BetaBase64PDFSourceParam:
//	case *anthropic.BetaPlainTextSourceParam:
//	case *anthropic.BetaContentBlockSourceParam:
//	case *anthropic.BetaURLPDFSourceParam:
//	case *anthropic.BetaFileDocumentSourceParam:
//	case *string:
//	default:
//	    fmt.Errorf("not present")
//	}
func (u betaContentBlockParamUnionSource) AsAny() any { return u.any }

// Returns a pointer to the underlying variant's property, if present.
func (u betaContentBlockParamUnionSource) GetContent() *BetaContentBlockSourceContentUnionParam {
	switch vt := u.any.(type) {
	case *BetaRequestDocumentBlockSourceUnionParam:
		return vt.GetContent()
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaContentBlockParamUnionSource) GetData() *string {
	switch vt := u.any.(type) {
	case *BetaImageBlockParamSourceUnion:
		return vt.GetData()
	case *BetaRequestDocumentBlockSourceUnionParam:
		return vt.GetData()
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaContentBlockParamUnionSource) GetMediaType() *string {
	switch vt := u.any.(type) {
	case *BetaImageBlockParamSourceUnion:
		return vt.GetMediaType()
	case *BetaRequestDocumentBlockSourceUnionParam:
		return vt.GetMediaType()
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaContentBlockParamUnionSource) GetType() *string {
	switch vt := u.any.(type) {
	case *BetaImageBlockParamSourceUnion:
		return vt.GetType()
	case *BetaRequestDocumentBlockSourceUnionParam:
		return vt.GetType()
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaContentBlockParamUnionSource) GetURL() *string {
	switch vt := u.any.(type) {
	case *BetaImageBlockParamSourceUnion:
		return vt.GetURL()
	case *BetaRequestDocumentBlockSourceUnionParam:
		return vt.GetURL()
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaContentBlockParamUnionSource) GetFileID() *string {
	switch vt := u.any.(type) {
	case *BetaImageBlockParamSourceUnion:
		return vt.GetFileID()
	case *BetaRequestDocumentBlockSourceUnionParam:
		return vt.GetFileID()
	}
	return nil
}

// Returns a subunion which exports methods to access subproperties
//
// Or use AsAny() to get the underlying value
func (u BetaContentBlockParamUnion) GetContent() (res betaContentBlockParamUnionContent) {
	if vt := u.OfSearchResult; vt != nil {
		res.any = &vt.Content
	} else if vt := u.OfToolResult; vt != nil {
		res.any = &vt.Content
	} else if vt := u.OfWebSearchToolResult; vt != nil {
		res.any = vt.Content.asAny()
	} else if vt := u.OfWebFetchToolResult; vt != nil {
		res.any = vt.Content.asAny()
	} else if vt := u.OfAdvisorToolResult; vt != nil {
		res.any = vt.Content.asAny()
	} else if vt := u.OfCodeExecutionToolResult; vt != nil {
		res.any = vt.Content.asAny()
	} else if vt := u.OfBashCodeExecutionToolResult; vt != nil {
		res.any = vt.Content.asAny()
	} else if vt := u.OfTextEditorCodeExecutionToolResult; vt != nil {
		res.any = vt.Content.asAny()
	} else if vt := u.OfToolSearchToolResult; vt != nil {
		res.any = vt.Content.asAny()
	} else if vt := u.OfMCPToolResult; vt != nil {
		res.any = vt.Content.asAny()
	} else if vt := u.OfCompaction; vt != nil && vt.Content.Valid() {
		res.any = &vt.Content.Value
	}
	return
}

// Can have the runtime types [_[]BetaTextBlockParam],
// [_[]BetaToolResultBlockParamContentUnion], [*[]BetaWebSearchResultBlockParam],
// [*BetaWebFetchToolResultErrorBlockParam], [*BetaWebFetchBlockParam],
// [*BetaAdvisorToolResultErrorParam], [*BetaAdvisorResultBlockParam],
// [*BetaAdvisorRedactedResultBlockParam],
// [*BetaCodeExecutionToolResultErrorParam], [*BetaCodeExecutionResultBlockParam],
// [*BetaEncryptedCodeExecutionResultBlockParam],
// [*BetaBashCodeExecutionToolResultErrorParam],
// [*BetaBashCodeExecutionResultBlockParam],
// [*BetaTextEditorCodeExecutionToolResultErrorParam],
// [*BetaTextEditorCodeExecutionViewResultBlockParam],
// [*BetaTextEditorCodeExecutionCreateResultBlockParam],
// [*BetaTextEditorCodeExecutionStrReplaceResultBlockParam],
// [*BetaToolSearchToolResultErrorParam],
// [*BetaToolSearchToolSearchResultBlockParam], [*string]
type betaContentBlockParamUnionContent struct{ any }

// Use the following switch statement to get the type of the union:
//
//	switch u.AsAny().(type) {
//	case *[]anthropic.BetaTextBlockParam:
//	case *[]anthropic.BetaToolResultBlockParamContentUnion:
//	case *[]anthropic.BetaWebSearchResultBlockParam:
//	case *anthropic.BetaWebFetchToolResultErrorBlockParam:
//	case *anthropic.BetaWebFetchBlockParam:
//	case *anthropic.BetaAdvisorToolResultErrorParam:
//	case *anthropic.BetaAdvisorResultBlockParam:
//	case *anthropic.BetaAdvisorRedactedResultBlockParam:
//	case *anthropic.BetaCodeExecutionToolResultErrorParam:
//	case *anthropic.BetaCodeExecutionResultBlockParam:
//	case *anthropic.BetaEncryptedCodeExecutionResultBlockParam:
//	case *anthropic.BetaBashCodeExecutionToolResultErrorParam:
//	case *anthropic.BetaBashCodeExecutionResultBlockParam:
//	case *anthropic.BetaTextEditorCodeExecutionToolResultErrorParam:
//	case *anthropic.BetaTextEditorCodeExecutionViewResultBlockParam:
//	case *anthropic.BetaTextEditorCodeExecutionCreateResultBlockParam:
//	case *anthropic.BetaTextEditorCodeExecutionStrReplaceResultBlockParam:
//	case *anthropic.BetaToolSearchToolResultErrorParam:
//	case *anthropic.BetaToolSearchToolSearchResultBlockParam:
//	case *string:
//	default:
//	    fmt.Errorf("not present")
//	}
func (u betaContentBlockParamUnionContent) AsAny() any { return u.any }

// Returns a pointer to the underlying variant's property, if present.
func (u betaContentBlockParamUnionContent) GetURL() *string {
	switch vt := u.any.(type) {
	case *BetaWebFetchToolResultBlockParamContentUnion:
		return vt.GetURL()
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaContentBlockParamUnionContent) GetRetrievedAt() *string {
	switch vt := u.any.(type) {
	case *BetaWebFetchToolResultBlockParamContentUnion:
		return vt.GetRetrievedAt()
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaContentBlockParamUnionContent) GetText() *string {
	switch vt := u.any.(type) {
	case *BetaAdvisorToolResultBlockParamContentUnion:
		return vt.GetText()
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaContentBlockParamUnionContent) GetEncryptedContent() *string {
	switch vt := u.any.(type) {
	case *BetaAdvisorToolResultBlockParamContentUnion:
		return vt.GetEncryptedContent()
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaContentBlockParamUnionContent) GetEncryptedStdout() *string {
	switch vt := u.any.(type) {
	case *BetaCodeExecutionToolResultBlockParamContentUnion:
		return vt.GetEncryptedStdout()
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaContentBlockParamUnionContent) GetFileType() *string {
	switch vt := u.any.(type) {
	case *BetaTextEditorCodeExecutionToolResultBlockParamContentUnion:
		return vt.GetFileType()
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaContentBlockParamUnionContent) GetNumLines() *int64 {
	switch vt := u.any.(type) {
	case *BetaTextEditorCodeExecutionToolResultBlockParamContentUnion:
		return vt.GetNumLines()
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaContentBlockParamUnionContent) GetStartLine() *int64 {
	switch vt := u.any.(type) {
	case *BetaTextEditorCodeExecutionToolResultBlockParamContentUnion:
		return vt.GetStartLine()
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaContentBlockParamUnionContent) GetTotalLines() *int64 {
	switch vt := u.any.(type) {
	case *BetaTextEditorCodeExecutionToolResultBlockParamContentUnion:
		return vt.GetTotalLines()
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaContentBlockParamUnionContent) GetIsFileUpdate() *bool {
	switch vt := u.any.(type) {
	case *BetaTextEditorCodeExecutionToolResultBlockParamContentUnion:
		return vt.GetIsFileUpdate()
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaContentBlockParamUnionContent) GetLines() []string {
	switch vt := u.any.(type) {
	case *BetaTextEditorCodeExecutionToolResultBlockParamContentUnion:
		return vt.GetLines()
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaContentBlockParamUnionContent) GetNewLines() *int64 {
	switch vt := u.any.(type) {
	case *BetaTextEditorCodeExecutionToolResultBlockParamContentUnion:
		return vt.GetNewLines()
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaContentBlockParamUnionContent) GetNewStart() *int64 {
	switch vt := u.any.(type) {
	case *BetaTextEditorCodeExecutionToolResultBlockParamContentUnion:
		return vt.GetNewStart()
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaContentBlockParamUnionContent) GetOldLines() *int64 {
	switch vt := u.any.(type) {
	case *BetaTextEditorCodeExecutionToolResultBlockParamContentUnion:
		return vt.GetOldLines()
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaContentBlockParamUnionContent) GetOldStart() *int64 {
	switch vt := u.any.(type) {
	case *BetaTextEditorCodeExecutionToolResultBlockParamContentUnion:
		return vt.GetOldStart()
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaContentBlockParamUnionContent) GetToolReferences() []BetaToolReferenceBlockParam {
	switch vt := u.any.(type) {
	case *BetaToolSearchToolResultBlockParamContentUnion:
		return vt.GetToolReferences()
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaContentBlockParamUnionContent) GetErrorCode() *string {
	switch vt := u.any.(type) {
	case *BetaWebSearchToolResultBlockParamContentUnion:
		if vt.OfError != nil {
			return (*string)(&vt.OfError.ErrorCode)
		}
	case *BetaWebFetchToolResultBlockParamContentUnion:
		return vt.GetErrorCode()
	case *BetaAdvisorToolResultBlockParamContentUnion:
		return vt.GetErrorCode()
	case *BetaCodeExecutionToolResultBlockParamContentUnion:
		return vt.GetErrorCode()
	case *BetaBashCodeExecutionToolResultBlockParamContentUnion:
		return vt.GetErrorCode()
	case *BetaTextEditorCodeExecutionToolResultBlockParamContentUnion:
		return vt.GetErrorCode()
	case *BetaToolSearchToolResultBlockParamContentUnion:
		return vt.GetErrorCode()
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaContentBlockParamUnionContent) GetType() *string {
	switch vt := u.any.(type) {
	case *BetaWebSearchToolResultBlockParamContentUnion:
		if vt.OfError != nil {
			return (*string)(&vt.OfError.Type)
		}
	case *BetaWebFetchToolResultBlockParamContentUnion:
		return vt.GetType()
	case *BetaAdvisorToolResultBlockParamContentUnion:
		return vt.GetType()
	case *BetaCodeExecutionToolResultBlockParamContentUnion:
		return vt.GetType()
	case *BetaBashCodeExecutionToolResultBlockParamContentUnion:
		return vt.GetType()
	case *BetaTextEditorCodeExecutionToolResultBlockParamContentUnion:
		return vt.GetType()
	case *BetaToolSearchToolResultBlockParamContentUnion:
		return vt.GetType()
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaContentBlockParamUnionContent) GetStopReason() *string {
	switch vt := u.any.(type) {
	case *BetaAdvisorToolResultBlockParamContentUnion:
		return vt.GetStopReason()
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaContentBlockParamUnionContent) GetReturnCode() *int64 {
	switch vt := u.any.(type) {
	case *BetaCodeExecutionToolResultBlockParamContentUnion:
		return vt.GetReturnCode()
	case *BetaBashCodeExecutionToolResultBlockParamContentUnion:
		return vt.GetReturnCode()
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaContentBlockParamUnionContent) GetStderr() *string {
	switch vt := u.any.(type) {
	case *BetaCodeExecutionToolResultBlockParamContentUnion:
		return vt.GetStderr()
	case *BetaBashCodeExecutionToolResultBlockParamContentUnion:
		return vt.GetStderr()
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaContentBlockParamUnionContent) GetStdout() *string {
	switch vt := u.any.(type) {
	case *BetaCodeExecutionToolResultBlockParamContentUnion:
		return vt.GetStdout()
	case *BetaBashCodeExecutionToolResultBlockParamContentUnion:
		return vt.GetStdout()
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaContentBlockParamUnionContent) GetErrorMessage() *string {
	switch vt := u.any.(type) {
	case *BetaTextEditorCodeExecutionToolResultBlockParamContentUnion:
		return vt.GetErrorMessage()
	case *BetaToolSearchToolResultBlockParamContentUnion:
		return vt.GetErrorMessage()
	}
	return nil
}

// Returns a subunion which exports methods to access subproperties
//
// Or use AsAny() to get the underlying value
func (u betaContentBlockParamUnionContent) GetContent() (res betaContentBlockParamUnionContentContent) {
	switch vt := u.any.(type) {
	case *BetaWebFetchToolResultBlockParamContentUnion:
		res.any = vt.GetContent()
	case *BetaCodeExecutionToolResultBlockParamContentUnion:
		res.any = vt.GetContent()
	case *BetaBashCodeExecutionToolResultBlockParamContentUnion:
		res.any = vt.GetContent()
	case *BetaTextEditorCodeExecutionToolResultBlockParamContentUnion:
		res.any = vt.GetContent()
	}
	return res
}

// Can have the runtime types [*BetaRequestDocumentBlockParam],
// [_[]BetaCodeExecutionOutputBlockParam],
// [_[]BetaBashCodeExecutionOutputBlockParam], [*string]
type betaContentBlockParamUnionContentContent struct{ any }

// Use the following switch statement to get the type of the union:
//
//	switch u.AsAny().(type) {
//	case *anthropic.BetaRequestDocumentBlockParam:
//	case *[]anthropic.BetaCodeExecutionOutputBlockParam:
//	case *[]anthropic.BetaBashCodeExecutionOutputBlockParam:
//	case *string:
//	default:
//	    fmt.Errorf("not present")
//	}
func (u betaContentBlockParamUnionContentContent) AsAny() any { return u.any }

// Returns a pointer to the underlying variant's Input property, if present.
func (u BetaContentBlockParamUnion) GetInput() *any {
	if vt := u.OfToolUse; vt != nil {
		return &vt.Input
	} else if vt := u.OfServerToolUse; vt != nil {
		return &vt.Input
	} else if vt := u.OfMCPToolUse; vt != nil {
		return &vt.Input
	}
	return nil
}

// Returns a subunion which exports methods to access subproperties
//
// Or use AsAny() to get the underlying value
func (u BetaContentBlockParamUnion) GetCaller() (res betaContentBlockParamUnionCaller) {
	if vt := u.OfToolUse; vt != nil {
		res.any = vt.Caller.asAny()
	} else if vt := u.OfServerToolUse; vt != nil {
		res.any = vt.Caller.asAny()
	} else if vt := u.OfWebSearchToolResult; vt != nil {
		res.any = vt.Caller.asAny()
	} else if vt := u.OfWebFetchToolResult; vt != nil {
		res.any = vt.Caller.asAny()
	}
	return
}

// Can have the runtime types [*BetaDirectCallerParam],
// [*BetaServerToolCallerParam], [*BetaServerToolCaller20260120Param]
type betaContentBlockParamUnionCaller struct{ any }

// Use the following switch statement to get the type of the union:
//
//	switch u.AsAny().(type) {
//	case *anthropic.BetaDirectCallerParam:
//	case *anthropic.BetaServerToolCallerParam:
//	case *anthropic.BetaServerToolCaller20260120Param:
//	default:
//	    fmt.Errorf("not present")
//	}
func (u betaContentBlockParamUnionCaller) AsAny() any { return u.any }

// Returns a pointer to the underlying variant's property, if present.
func (u betaContentBlockParamUnionCaller) GetType() *string {
	switch vt := u.any.(type) {
	case *BetaToolUseBlockParamCallerUnion:
		return vt.GetType()
	case *BetaServerToolUseBlockParamCallerUnion:
		return vt.GetType()
	case *BetaWebSearchToolResultBlockParamCallerUnion:
		return vt.GetType()
	case *BetaWebFetchToolResultBlockParamCallerUnion:
		return vt.GetType()
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaContentBlockParamUnionCaller) GetToolID() *string {
	switch vt := u.any.(type) {
	case *BetaToolUseBlockParamCallerUnion:
		return vt.GetToolID()
	case *BetaServerToolUseBlockParamCallerUnion:
		return vt.GetToolID()
	case *BetaWebSearchToolResultBlockParamCallerUnion:
		return vt.GetToolID()
	case *BetaWebFetchToolResultBlockParamCallerUnion:
		return vt.GetToolID()
	}
	return nil
}

// Returns a subunion which exports methods to access subproperties
//
// Or use AsAny() to get the underlying value
func (u BetaContentBlockParamUnion) GetTool() (res betaContentBlockParamUnionTool) {
	if vt := u.OfToolAddition; vt != nil {
		res.any = vt.Tool.asAny()
	} else if vt := u.OfToolRemoval; vt != nil {
		res.any = vt.Tool.asAny()
	}
	return
}

// Can have the runtime types [*BetaToolChangeToolReferenceParam],
// [*BetaToolChangeMCPToolReferenceParam],
// [*BetaToolChangeMCPToolsetReferenceParam]
type betaContentBlockParamUnionTool struct{ any }

// Use the following switch statement to get the type of the union:
//
//	switch u.AsAny().(type) {
//	case *anthropic.BetaToolChangeToolReferenceParam:
//	case *anthropic.BetaToolChangeMCPToolReferenceParam:
//	case *anthropic.BetaToolChangeMCPToolsetReferenceParam:
//	default:
//	    fmt.Errorf("not present")
//	}
func (u betaContentBlockParamUnionTool) AsAny() any { return u.any }

// Returns a pointer to the underlying variant's property, if present.
func (u betaContentBlockParamUnionTool) GetName() *string {
	switch vt := u.any.(type) {
	case *BetaRequestToolAdditionBlockToolUnionParam:
		return vt.GetName()
	case *BetaRequestToolRemovalBlockToolUnionParam:
		return vt.GetName()
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaContentBlockParamUnionTool) GetType() *string {
	switch vt := u.any.(type) {
	case *BetaRequestToolAdditionBlockToolUnionParam:
		return vt.GetType()
	case *BetaRequestToolRemovalBlockToolUnionParam:
		return vt.GetType()
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaContentBlockParamUnionTool) GetServerName() *string {
	switch vt := u.any.(type) {
	case *BetaRequestToolAdditionBlockToolUnionParam:
		return vt.GetServerName()
	case *BetaRequestToolRemovalBlockToolUnionParam:
		return vt.GetServerName()
	}
	return nil
}

func init() {
	apijson.RegisterUnion[BetaContentBlockParamUnion](
		"type",
		apijson.Discriminator[BetaTextBlockParam]("text"),
		apijson.Discriminator[BetaImageBlockParam]("image"),
		apijson.Discriminator[BetaRequestDocumentBlockParam]("document"),
		apijson.Discriminator[BetaSearchResultBlockParam]("search_result"),
		apijson.Discriminator[BetaThinkingBlockParam]("thinking"),
		apijson.Discriminator[BetaRedactedThinkingBlockParam]("redacted_thinking"),
		apijson.Discriminator[BetaToolUseBlockParam]("tool_use"),
		apijson.Discriminator[BetaToolResultBlockParam]("tool_result"),
		apijson.Discriminator[BetaServerToolUseBlockParam]("server_tool_use"),
		apijson.Discriminator[BetaWebSearchToolResultBlockParam]("web_search_tool_result"),
		apijson.Discriminator[BetaWebFetchToolResultBlockParam]("web_fetch_tool_result"),
		apijson.Discriminator[BetaAdvisorToolResultBlockParam]("advisor_tool_result"),
		apijson.Discriminator[BetaCodeExecutionToolResultBlockParam]("code_execution_tool_result"),
		apijson.Discriminator[BetaBashCodeExecutionToolResultBlockParam]("bash_code_execution_tool_result"),
		apijson.Discriminator[BetaTextEditorCodeExecutionToolResultBlockParam]("text_editor_code_execution_tool_result"),
		apijson.Discriminator[BetaToolSearchToolResultBlockParam]("tool_search_tool_result"),
		apijson.Discriminator[BetaMCPToolUseBlockParam]("mcp_tool_use"),
		apijson.Discriminator[BetaRequestMCPToolResultBlockParam]("mcp_tool_result"),
		apijson.Discriminator[BetaContainerUploadBlockParam]("container_upload"),
		apijson.Discriminator[BetaCompactionBlockParam]("compaction"),
		apijson.Discriminator[BetaRequestToolAdditionBlockParam]("tool_addition"),
		apijson.Discriminator[BetaRequestToolRemovalBlockParam]("tool_removal"),
		apijson.Discriminator[BetaFallbackBlockParam]("fallback"),
	)
}

// The properties Content, Type are required.
type BetaContentBlockSourceParam struct {
	Content BetaContentBlockSourceContentUnionParam `json:"content,omitzero" api:"required"`
	// This field can be elided, and will marshal its zero value as "content".
	Type constant.Content `json:"type" default:"content"`
	paramObj
}

func (r BetaContentBlockSourceParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaContentBlockSourceParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaContentBlockSourceParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Only one field can be non-zero.
//
// Use [param.IsOmitted] to confirm if a field is set.
type BetaContentBlockSourceContentUnionParam struct {
	OfString                        param.Opt[string]                         `json:",omitzero,inline"`
	OfBetaContentBlockSourceContent []BetaContentBlockSourceContentUnionParam `json:",omitzero,inline"`
	paramUnion
}

func (u BetaContentBlockSourceContentUnionParam) MarshalJSON() ([]byte, error) {
	return param.MarshalUnion(u, u.OfString, u.OfBetaContentBlockSourceContent)
}
func (u *BetaContentBlockSourceContentUnionParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, u)
}

func (u *BetaContentBlockSourceContentUnionParam) asAny() any {
	if !param.IsOmitted(u.OfString) {
		return &u.OfString.Value
	} else if !param.IsOmitted(u.OfBetaContentBlockSourceContent) {
		return &u.OfBetaContentBlockSourceContent
	}
	return nil
}

type BetaContextManagementConfigParam struct {
	// List of context management edits to apply
	Edits []BetaContextManagementConfigEditUnionParam `json:"edits,omitzero"`
	paramObj
}

func (r BetaContextManagementConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaContextManagementConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaContextManagementConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Only one field can be non-zero.
//
// Use [param.IsOmitted] to confirm if a field is set.
type BetaContextManagementConfigEditUnionParam struct {
	OfClearToolUses20250919 *BetaClearToolUses20250919EditParam `json:",omitzero,inline"`
	OfClearThinking20251015 *BetaClearThinking20251015EditParam `json:",omitzero,inline"`
	OfCompact20260112       *BetaCompact20260112EditParam       `json:",omitzero,inline"`
	paramUnion
}

func (u BetaContextManagementConfigEditUnionParam) MarshalJSON() ([]byte, error) {
	return param.MarshalUnion(u, u.OfClearToolUses20250919, u.OfClearThinking20251015, u.OfCompact20260112)
}
func (u *BetaContextManagementConfigEditUnionParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, u)
}

func (u *BetaContextManagementConfigEditUnionParam) asAny() any {
	if !param.IsOmitted(u.OfClearToolUses20250919) {
		return u.OfClearToolUses20250919
	} else if !param.IsOmitted(u.OfClearThinking20251015) {
		return u.OfClearThinking20251015
	} else if !param.IsOmitted(u.OfCompact20260112) {
		return u.OfCompact20260112
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaContextManagementConfigEditUnionParam) GetClearAtLeast() *BetaInputTokensClearAtLeastParam {
	if vt := u.OfClearToolUses20250919; vt != nil {
		return &vt.ClearAtLeast
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaContextManagementConfigEditUnionParam) GetClearToolInputs() *BetaClearToolUses20250919EditClearToolInputsUnionParam {
	if vt := u.OfClearToolUses20250919; vt != nil {
		return &vt.ClearToolInputs
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaContextManagementConfigEditUnionParam) GetExcludeTools() []string {
	if vt := u.OfClearToolUses20250919; vt != nil {
		return vt.ExcludeTools
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaContextManagementConfigEditUnionParam) GetInstructions() *string {
	if vt := u.OfCompact20260112; vt != nil && vt.Instructions.Valid() {
		return &vt.Instructions.Value
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaContextManagementConfigEditUnionParam) GetPauseAfterCompaction() *bool {
	if vt := u.OfCompact20260112; vt != nil && vt.PauseAfterCompaction.Valid() {
		return &vt.PauseAfterCompaction.Value
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaContextManagementConfigEditUnionParam) GetType() *string {
	if vt := u.OfClearToolUses20250919; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfClearThinking20251015; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfCompact20260112; vt != nil {
		return (*string)(&vt.Type)
	}
	return nil
}

// Returns a subunion which exports methods to access subproperties
//
// Or use AsAny() to get the underlying value
func (u BetaContextManagementConfigEditUnionParam) GetKeep() (res betaContextManagementConfigEditUnionParamKeep) {
	if vt := u.OfClearToolUses20250919; vt != nil {
		res.any = &vt.Keep
	} else if vt := u.OfClearThinking20251015; vt != nil {
		res.any = vt.Keep.asAny()
	}
	return
}

// Can have the runtime types [*BetaToolUsesKeepParam], [*string]
type betaContextManagementConfigEditUnionParamKeep struct{ any }

// Use the following switch statement to get the type of the union:
//
//	switch u.AsAny().(type) {
//	case *anthropic.BetaToolUsesKeepParam:
//	case *string:
//	default:
//	    fmt.Errorf("not present")
//	}
func (u betaContextManagementConfigEditUnionParamKeep) AsAny() any { return u.any }

// Returns a pointer to the underlying variant's property, if present.
func (u betaContextManagementConfigEditUnionParamKeep) GetType() *string {
	switch vt := u.any.(type) {
	case *BetaToolUsesKeepParam:
		return (*string)(&vt.Type)
	case *BetaClearThinking20251015EditKeepUnionParam:
		return vt.GetType()
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaContextManagementConfigEditUnionParamKeep) GetValue() *int64 {
	switch vt := u.any.(type) {
	case *BetaToolUsesKeepParam:
		return (*int64)(&vt.Value)
	case *BetaClearThinking20251015EditKeepUnionParam:
		return vt.GetValue()
	}
	return nil
}

func init() {
	apijson.RegisterUnion[BetaContextManagementConfigEditUnionParam](
		"type",
		apijson.Discriminator[BetaClearToolUses20250919EditParam]("clear_tool_uses_20250919"),
		apijson.Discriminator[BetaClearThinking20251015EditParam]("clear_thinking_20251015"),
		apijson.Discriminator[BetaCompact20260112EditParam]("compact_20260112"),
	)
}

type BetaContextManagementResponse struct {
	// List of context management edits that were applied.
	AppliedEdits []BetaContextManagementResponseAppliedEditUnion `json:"applied_edits" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		AppliedEdits respjson.Field
		ExtraFields  map[string]respjson.Field
		raw          string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaContextManagementResponse) RawJSON() string { return r.JSON.raw }
func (r *BetaContextManagementResponse) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// BetaContextManagementResponseAppliedEditUnion contains all possible properties
// and values from [BetaClearToolUses20250919EditResponse],
// [BetaClearThinking20251015EditResponse].
//
// Use the [BetaContextManagementResponseAppliedEditUnion.AsAny] method to switch
// on the variant.
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
type BetaContextManagementResponseAppliedEditUnion struct {
	ClearedInputTokens int64 `json:"cleared_input_tokens"`
	// This field is from variant [BetaClearToolUses20250919EditResponse].
	ClearedToolUses int64 `json:"cleared_tool_uses"`
	// Any of "clear_tool_uses_20250919", "clear_thinking_20251015".
	Type string `json:"type"`
	// This field is from variant [BetaClearThinking20251015EditResponse].
	ClearedThinkingTurns int64 `json:"cleared_thinking_turns"`
	JSON                 struct {
		ClearedInputTokens   respjson.Field
		ClearedToolUses      respjson.Field
		Type                 respjson.Field
		ClearedThinkingTurns respjson.Field
		raw                  string
	} `json:"-"`
}

// anyBetaContextManagementResponseAppliedEdit is implemented by each variant of
// [BetaContextManagementResponseAppliedEditUnion] to add type safety for the
// return type of [BetaContextManagementResponseAppliedEditUnion.AsAny]
type anyBetaContextManagementResponseAppliedEdit interface {
	implBetaContextManagementResponseAppliedEditUnion()
}

func (BetaClearToolUses20250919EditResponse) implBetaContextManagementResponseAppliedEditUnion() {}
func (BetaClearThinking20251015EditResponse) implBetaContextManagementResponseAppliedEditUnion() {}

// Use the following switch statement to find the correct variant
//
//	switch variant := BetaContextManagementResponseAppliedEditUnion.AsAny().(type) {
//	case anthropic.BetaClearToolUses20250919EditResponse:
//	case anthropic.BetaClearThinking20251015EditResponse:
//	default:
//	  fmt.Errorf("no variant present")
//	}
func (u BetaContextManagementResponseAppliedEditUnion) AsAny() anyBetaContextManagementResponseAppliedEdit {
	switch u.Type {
	case "clear_tool_uses_20250919":
		return u.AsClearToolUses20250919()
	case "clear_thinking_20251015":
		return u.AsClearThinking20251015()
	}
	return nil
}

func (u BetaContextManagementResponseAppliedEditUnion) AsClearToolUses20250919() (v BetaClearToolUses20250919EditResponse) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaContextManagementResponseAppliedEditUnion) AsClearThinking20251015() (v BetaClearThinking20251015EditResponse) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u BetaContextManagementResponseAppliedEditUnion) RawJSON() string { return u.JSON.raw }

func (r *BetaContextManagementResponseAppliedEditUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaCountTokensContextManagementResponse struct {
	// The original token count before context management was applied
	OriginalInputTokens int64 `json:"original_input_tokens" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		OriginalInputTokens respjson.Field
		ExtraFields         map[string]respjson.Field
		raw                 string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaCountTokensContextManagementResponse) RawJSON() string { return r.JSON.raw }
func (r *BetaCountTokensContextManagementResponse) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Response envelope for request-level diagnostics. Present (possibly null)
// whenever the caller supplied `diagnostics` on the request.
type BetaDiagnostics struct {
	// Explains why the prompt cache could not fully reuse the prefix from the request
	// identified by `diagnostics.previous_message_id`. `null` means diagnosis is still
	// pending — the response was serialized before the background comparison
	// completed.
	CacheMissReason BetaDiagnosticsCacheMissReasonUnion `json:"cache_miss_reason" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CacheMissReason respjson.Field
		ExtraFields     map[string]respjson.Field
		raw             string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaDiagnostics) RawJSON() string { return r.JSON.raw }
func (r *BetaDiagnostics) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// BetaDiagnosticsCacheMissReasonUnion contains all possible properties and values
// from [BetaCacheMissModelChanged], [BetaCacheMissSystemChanged],
// [BetaCacheMissToolsChanged], [BetaCacheMissMessagesChanged],
// [BetaCacheMissPreviousMessageNotFound], [BetaCacheMissUnavailable].
//
// Use the [BetaDiagnosticsCacheMissReasonUnion.AsAny] method to switch on the
// variant.
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
type BetaDiagnosticsCacheMissReasonUnion struct {
	CacheMissedInputTokens int64 `json:"cache_missed_input_tokens"`
	// Any of "model_changed", "system_changed", "tools_changed", "messages_changed",
	// "previous_message_not_found", "unavailable".
	Type string `json:"type"`
	JSON struct {
		CacheMissedInputTokens respjson.Field
		Type                   respjson.Field
		raw                    string
	} `json:"-"`
}

// anyBetaDiagnosticsCacheMissReason is implemented by each variant of
// [BetaDiagnosticsCacheMissReasonUnion] to add type safety for the return type of
// [BetaDiagnosticsCacheMissReasonUnion.AsAny]
type anyBetaDiagnosticsCacheMissReason interface {
	implBetaDiagnosticsCacheMissReasonUnion()
}

func (BetaCacheMissModelChanged) implBetaDiagnosticsCacheMissReasonUnion()            {}
func (BetaCacheMissSystemChanged) implBetaDiagnosticsCacheMissReasonUnion()           {}
func (BetaCacheMissToolsChanged) implBetaDiagnosticsCacheMissReasonUnion()            {}
func (BetaCacheMissMessagesChanged) implBetaDiagnosticsCacheMissReasonUnion()         {}
func (BetaCacheMissPreviousMessageNotFound) implBetaDiagnosticsCacheMissReasonUnion() {}
func (BetaCacheMissUnavailable) implBetaDiagnosticsCacheMissReasonUnion()             {}

// Use the following switch statement to find the correct variant
//
//	switch variant := BetaDiagnosticsCacheMissReasonUnion.AsAny().(type) {
//	case anthropic.BetaCacheMissModelChanged:
//	case anthropic.BetaCacheMissSystemChanged:
//	case anthropic.BetaCacheMissToolsChanged:
//	case anthropic.BetaCacheMissMessagesChanged:
//	case anthropic.BetaCacheMissPreviousMessageNotFound:
//	case anthropic.BetaCacheMissUnavailable:
//	default:
//	  fmt.Errorf("no variant present")
//	}
func (u BetaDiagnosticsCacheMissReasonUnion) AsAny() anyBetaDiagnosticsCacheMissReason {
	switch u.Type {
	case "model_changed":
		return u.AsModelChanged()
	case "system_changed":
		return u.AsSystemChanged()
	case "tools_changed":
		return u.AsToolsChanged()
	case "messages_changed":
		return u.AsMessagesChanged()
	case "previous_message_not_found":
		return u.AsPreviousMessageNotFound()
	case "unavailable":
		return u.AsUnavailable()
	}
	return nil
}

func (u BetaDiagnosticsCacheMissReasonUnion) AsModelChanged() (v BetaCacheMissModelChanged) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaDiagnosticsCacheMissReasonUnion) AsSystemChanged() (v BetaCacheMissSystemChanged) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaDiagnosticsCacheMissReasonUnion) AsToolsChanged() (v BetaCacheMissToolsChanged) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaDiagnosticsCacheMissReasonUnion) AsMessagesChanged() (v BetaCacheMissMessagesChanged) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaDiagnosticsCacheMissReasonUnion) AsPreviousMessageNotFound() (v BetaCacheMissPreviousMessageNotFound) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaDiagnosticsCacheMissReasonUnion) AsUnavailable() (v BetaCacheMissUnavailable) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u BetaDiagnosticsCacheMissReasonUnion) RawJSON() string { return u.JSON.raw }

func (r *BetaDiagnosticsCacheMissReasonUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Request-level diagnostics. Currently carries the previous response id for
// prompt-cache divergence reporting.
type BetaDiagnosticsParam struct {
	// The `id` (`msg_...`) from this client's previous /v1/messages response. The
	// server compares that request's prompt fingerprint against this one and returns
	// `diagnostics.cache_miss_reason` when the prompt-cache prefix could not be
	// reused. Pass `null` on the first turn to opt in without a prior message to
	// compare.
	PreviousMessageID param.Opt[string] `json:"previous_message_id,omitzero"`
	paramObj
}

func (r BetaDiagnosticsParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaDiagnosticsParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaDiagnosticsParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Tool invocation directly from the model.
type BetaDirectCaller struct {
	Type constant.Direct `json:"type" default:"direct"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaDirectCaller) RawJSON() string { return r.JSON.raw }
func (r *BetaDirectCaller) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// ToParam converts this BetaDirectCaller to a BetaDirectCallerParam.
//
// Warning: the fields of the param type will not be present. ToParam should only
// be used at the last possible moment before sending a request. Test for this with
// BetaDirectCallerParam.Overrides()
func (r BetaDirectCaller) ToParam() BetaDirectCallerParam {
	return param.Override[BetaDirectCallerParam](json.RawMessage(r.RawJSON()))
}

func NewBetaDirectCallerParam() BetaDirectCallerParam {
	return BetaDirectCallerParam{
		Type: "direct",
	}
}

// Tool invocation directly from the model.
//
// This struct has a constant value, construct it with [NewBetaDirectCallerParam].
type BetaDirectCallerParam struct {
	Type constant.Direct `json:"type" default:"direct"`
	paramObj
}

func (r BetaDirectCallerParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaDirectCallerParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaDirectCallerParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaDocumentBlock struct {
	// Citation configuration for the document
	Citations BetaCitationConfig           `json:"citations" api:"required"`
	Source    BetaDocumentBlockSourceUnion `json:"source" api:"required"`
	// The title of the document
	Title string            `json:"title" api:"required"`
	Type  constant.Document `json:"type" default:"document"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Citations   respjson.Field
		Source      respjson.Field
		Title       respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaDocumentBlock) RawJSON() string { return r.JSON.raw }
func (r *BetaDocumentBlock) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// BetaDocumentBlockSourceUnion contains all possible properties and values from
// [BetaBase64PDFSource], [BetaPlainTextSource].
//
// Use the [BetaDocumentBlockSourceUnion.AsAny] method to switch on the variant.
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
type BetaDocumentBlockSourceUnion struct {
	Data      string `json:"data"`
	MediaType string `json:"media_type"`
	// Any of "base64", "text".
	Type string `json:"type"`
	JSON struct {
		Data      respjson.Field
		MediaType respjson.Field
		Type      respjson.Field
		raw       string
	} `json:"-"`
}

// anyBetaDocumentBlockSource is implemented by each variant of
// [BetaDocumentBlockSourceUnion] to add type safety for the return type of
// [BetaDocumentBlockSourceUnion.AsAny]
type anyBetaDocumentBlockSource interface {
	implBetaDocumentBlockSourceUnion()
}

func (BetaBase64PDFSource) implBetaDocumentBlockSourceUnion() {}
func (BetaPlainTextSource) implBetaDocumentBlockSourceUnion() {}

// Use the following switch statement to find the correct variant
//
//	switch variant := BetaDocumentBlockSourceUnion.AsAny().(type) {
//	case anthropic.BetaBase64PDFSource:
//	case anthropic.BetaPlainTextSource:
//	default:
//	  fmt.Errorf("no variant present")
//	}
func (u BetaDocumentBlockSourceUnion) AsAny() anyBetaDocumentBlockSource {
	switch u.Type {
	case "base64":
		return u.AsBase64()
	case "text":
		return u.AsText()
	}
	return nil
}

func (u BetaDocumentBlockSourceUnion) AsBase64() (v BetaBase64PDFSource) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaDocumentBlockSourceUnion) AsText() (v BetaPlainTextSource) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u BetaDocumentBlockSourceUnion) RawJSON() string { return u.JSON.raw }

func (r *BetaDocumentBlockSourceUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Code execution result with encrypted stdout for PFC + web_search results.
type BetaEncryptedCodeExecutionResultBlock struct {
	Content         []BetaCodeExecutionOutputBlock        `json:"content" api:"required"`
	EncryptedStdout string                                `json:"encrypted_stdout" api:"required"`
	ReturnCode      int64                                 `json:"return_code" api:"required"`
	Stderr          string                                `json:"stderr" api:"required"`
	Type            constant.EncryptedCodeExecutionResult `json:"type" default:"encrypted_code_execution_result"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Content         respjson.Field
		EncryptedStdout respjson.Field
		ReturnCode      respjson.Field
		Stderr          respjson.Field
		Type            respjson.Field
		ExtraFields     map[string]respjson.Field
		raw             string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaEncryptedCodeExecutionResultBlock) RawJSON() string { return r.JSON.raw }
func (r *BetaEncryptedCodeExecutionResultBlock) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Code execution result with encrypted stdout for PFC + web_search results.
//
// The properties Content, EncryptedStdout, ReturnCode, Stderr, Type are required.
type BetaEncryptedCodeExecutionResultBlockParam struct {
	Content         []BetaCodeExecutionOutputBlockParam `json:"content,omitzero" api:"required"`
	EncryptedStdout string                              `json:"encrypted_stdout" api:"required"`
	ReturnCode      int64                               `json:"return_code" api:"required"`
	Stderr          string                              `json:"stderr" api:"required"`
	// This field can be elided, and will marshal its zero value as
	// "encrypted_code_execution_result".
	Type constant.EncryptedCodeExecutionResult `json:"type" default:"encrypted_code_execution_result"`
	paramObj
}

func (r BetaEncryptedCodeExecutionResultBlockParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaEncryptedCodeExecutionResultBlockParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaEncryptedCodeExecutionResultBlockParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Marks the point in `content` where one model's output gives way to the next.
//
// One block appears per hop where a preceding model actually ran this turn and
// declined. A turn where no preceding model ran and declined has no such boundary
// and carries no block — the signal for whether a fallback model served the
// response is the presence of a `fallback_message` entry in `usage.iterations`,
// not this block.
//
// The block is treated like a server-tool content block for streaming: it arrives
// via the standard `content_block_start` / `content_block_stop` pair and carries
// no deltas.
type BetaFallbackBlock struct {
	// The model whose output ends at this point — the model that declined at this hop.
	// When the declining hop is the requested model, its `model` echoes the top-level
	// `model` string the caller sent (alias or canonical); when the declining hop is a
	// fallback model, its `model` is that model's canonical id.
	From BetaFallbackInfo `json:"from" api:"required"`
	// The fallback model producing the content that follows this block. Its `model` is
	// always the canonical id.
	To BetaFallbackInfo `json:"to" api:"required"`
	// What caused the `from` model to hand over at this hop.
	Trigger BetaFallbackRefusalTrigger `json:"trigger" api:"required"`
	Type    constant.Fallback          `json:"type" default:"fallback"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		From        respjson.Field
		To          respjson.Field
		Trigger     respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaFallbackBlock) RawJSON() string { return r.JSON.raw }
func (r *BetaFallbackBlock) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// A `fallback` block echoed back from a prior response.
//
// Accepted in `messages[].content` and not rendered into the prompt; not validated
// against the request's `fallbacks` chain or top-level `model`.
//
// Echo the assistant turn back verbatim, including this block in its original
// position. The block marks the boundary between content produced before and after
// a fallback hop, and the server relies on that boundary to validate the turn:
// when thinking runs flank the boundary, omitting the block merges them into one
// span the server cannot validate (the request is rejected), and moving it into
// the middle of a single run is likewise rejected; between non-thinking blocks the
// block's placement has no validation effect.
//
// The properties From, To, Type are required.
type BetaFallbackBlockParam struct {
	// Identifies one hop of a fallback transition.
	From BetaFallbackInfoParam `json:"from,omitzero" api:"required"`
	// Identifies one hop of a fallback transition.
	To BetaFallbackInfoParam `json:"to,omitzero" api:"required"`
	// The response block's `trigger`, echoed verbatim. Accepted and ignored by the
	// server; any object or `null` is allowed.
	Trigger any `json:"trigger,omitzero"`
	// This field can be elided, and will marshal its zero value as "fallback".
	Type constant.Fallback `json:"type" default:"fallback"`
	paramObj
}

func (r BetaFallbackBlockParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaFallbackBlockParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaFallbackBlockParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// No reprice was applied; `reason` says why.
type BetaFallbackCreditNotApplied struct {
	// Why the reprice was not applied.
	//
	// A closed enum; additions to the redemption-check vocabulary arrive as deliberate
	// schema updates.
	//
	// Any of "body_mismatch", "continuation_excluded", "continuation_only", "expired",
	// "invalid_target_model", "not_enabled", "reprice_unavailable",
	// "temporarily_unavailable", "variant_fields_present", "wrong_organization",
	// "wrong_platform", "wrong_workspace".
	Reason BetaFallbackCreditNotAppliedReason `json:"reason" api:"required"`
	Type   constant.NotApplied                `json:"type" default:"not_applied"`
	// Request fields to remove before retrying, so the retry can redeem this token.
	//
	// Present exactly when `reason` is `variant_fields_present` — never null, never an
	// empty array; absent otherwise. Fields are named only from your own request, and
	// only after the sealed variant hash matched. A served best-effort retry has
	// already been billed at normal price; nothing redeems retroactively, but a
	// corrected re-send inside the token's five-minute window can still redeem.
	RemoveToRedeem []string `json:"remove_to_redeem" api:"nullable"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Reason         respjson.Field
		Type           respjson.Field
		RemoveToRedeem respjson.Field
		ExtraFields    map[string]respjson.Field
		raw            string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaFallbackCreditNotApplied) RawJSON() string { return r.JSON.raw }
func (r *BetaFallbackCreditNotApplied) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Why the reprice was not applied.
//
// A closed enum; additions to the redemption-check vocabulary arrive as deliberate
// schema updates.
type BetaFallbackCreditNotAppliedReason string

const (
	BetaFallbackCreditNotAppliedReasonBodyMismatch           BetaFallbackCreditNotAppliedReason = "body_mismatch"
	BetaFallbackCreditNotAppliedReasonContinuationExcluded   BetaFallbackCreditNotAppliedReason = "continuation_excluded"
	BetaFallbackCreditNotAppliedReasonContinuationOnly       BetaFallbackCreditNotAppliedReason = "continuation_only"
	BetaFallbackCreditNotAppliedReasonExpired                BetaFallbackCreditNotAppliedReason = "expired"
	BetaFallbackCreditNotAppliedReasonInvalidTargetModel     BetaFallbackCreditNotAppliedReason = "invalid_target_model"
	BetaFallbackCreditNotAppliedReasonNotEnabled             BetaFallbackCreditNotAppliedReason = "not_enabled"
	BetaFallbackCreditNotAppliedReasonRepriceUnavailable     BetaFallbackCreditNotAppliedReason = "reprice_unavailable"
	BetaFallbackCreditNotAppliedReasonTemporarilyUnavailable BetaFallbackCreditNotAppliedReason = "temporarily_unavailable"
	BetaFallbackCreditNotAppliedReasonVariantFieldsPresent   BetaFallbackCreditNotAppliedReason = "variant_fields_present"
	BetaFallbackCreditNotAppliedReasonWrongOrganization      BetaFallbackCreditNotAppliedReason = "wrong_organization"
	BetaFallbackCreditNotAppliedReasonWrongPlatform          BetaFallbackCreditNotAppliedReason = "wrong_platform"
	BetaFallbackCreditNotAppliedReasonWrongWorkspace         BetaFallbackCreditNotAppliedReason = "wrong_workspace"
)

// The reprice was applied: the retry is billed as if the conversation had been on
// the retry model all along.
type BetaFallbackCreditRedeemed struct {
	Type constant.Redeemed `json:"type" default:"redeemed"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaFallbackCreditRedeemed) RawJSON() string { return r.JSON.raw }
func (r *BetaFallbackCreditRedeemed) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Object form of `fallback_credit_token`: the token plus a redemption mode.
//
// Requires `anthropic-beta: fallback-credit-2026-07-01`; without that header the
// field accepts the bare string only. The bare string and the mode-less object are
// equivalent (both select `strict`), so wrapping an existing token changes nothing
// by itself.
//
// The property Token is required.
type BetaFallbackCreditTokenParam struct {
	// The opaque `fallback_credit_token` from a prior refusal's `stop_details` — the
	// same string the bare-string form carries.
	Token string `json:"token" api:"required"`
	// How a failing token affects the retry. `strict` (the default, and the
	// bare-string behavior): a failing redemption is a 400 and the retry is not
	// served. `best_effort`: the retry is served either way — a token-layer failure no
	// longer rejects the request; the retry proceeds at normal price and the outcome
	// is reported on the response's `usage.fallback_credit`. Two failures stay hard in
	// both modes: a malformed token, and combining `fallback_credit_token` with
	// `fallbacks`.
	//
	// Any of "strict", "best_effort".
	Mode BetaFallbackCreditTokenParamMode `json:"mode,omitzero"`
	paramObj
}

func (r BetaFallbackCreditTokenParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaFallbackCreditTokenParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaFallbackCreditTokenParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// How a failing token affects the retry. `strict` (the default, and the
// bare-string behavior): a failing redemption is a 400 and the retry is not
// served. `best_effort`: the retry is served either way — a token-layer failure no
// longer rejects the request; the retry proceeds at normal price and the outcome
// is reported on the response's `usage.fallback_credit`. Two failures stay hard in
// both modes: a malformed token, and combining `fallback_credit_token` with
// `fallbacks`.
type BetaFallbackCreditTokenParamMode string

const (
	BetaFallbackCreditTokenParamModeStrict     BetaFallbackCreditTokenParamMode = "strict"
	BetaFallbackCreditTokenParamModeBestEffort BetaFallbackCreditTokenParamMode = "best_effort"
)

// Outcome of the `fallback_credit_token` presented on this request.
type BetaFallbackCreditUsage struct {
	// Whether the fallback-credit reprice was applied to this response's billing.
	//
	// A union discriminated on `type`. `redeemed`: the retry is billed as if the
	// conversation had been on the retry model all along — including when the
	// resulting shift is zero because there was nothing to move. `not_applied`: no
	// reprice was applied; the arm's `reason` says why.
	Status BetaFallbackCreditUsageStatusUnion `json:"status" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Status      respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaFallbackCreditUsage) RawJSON() string { return r.JSON.raw }
func (r *BetaFallbackCreditUsage) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// BetaFallbackCreditUsageStatusUnion contains all possible properties and values
// from [BetaFallbackCreditRedeemed], [BetaFallbackCreditNotApplied].
//
// Use the [BetaFallbackCreditUsageStatusUnion.AsAny] method to switch on the
// variant.
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
type BetaFallbackCreditUsageStatusUnion struct {
	// Any of "redeemed", "not_applied".
	Type string `json:"type"`
	// This field is from variant [BetaFallbackCreditNotApplied].
	Reason BetaFallbackCreditNotAppliedReason `json:"reason"`
	// This field is from variant [BetaFallbackCreditNotApplied].
	RemoveToRedeem []string `json:"remove_to_redeem"`
	JSON           struct {
		Type           respjson.Field
		Reason         respjson.Field
		RemoveToRedeem respjson.Field
		raw            string
	} `json:"-"`
}

// anyBetaFallbackCreditUsageStatus is implemented by each variant of
// [BetaFallbackCreditUsageStatusUnion] to add type safety for the return type of
// [BetaFallbackCreditUsageStatusUnion.AsAny]
type anyBetaFallbackCreditUsageStatus interface {
	implBetaFallbackCreditUsageStatusUnion()
}

func (BetaFallbackCreditRedeemed) implBetaFallbackCreditUsageStatusUnion()   {}
func (BetaFallbackCreditNotApplied) implBetaFallbackCreditUsageStatusUnion() {}

// Use the following switch statement to find the correct variant
//
//	switch variant := BetaFallbackCreditUsageStatusUnion.AsAny().(type) {
//	case anthropic.BetaFallbackCreditRedeemed:
//	case anthropic.BetaFallbackCreditNotApplied:
//	default:
//	  fmt.Errorf("no variant present")
//	}
func (u BetaFallbackCreditUsageStatusUnion) AsAny() anyBetaFallbackCreditUsageStatus {
	switch u.Type {
	case "redeemed":
		return u.AsRedeemed()
	case "not_applied":
		return u.AsNotApplied()
	}
	return nil
}

func (u BetaFallbackCreditUsageStatusUnion) AsRedeemed() (v BetaFallbackCreditRedeemed) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaFallbackCreditUsageStatusUnion) AsNotApplied() (v BetaFallbackCreditNotApplied) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u BetaFallbackCreditUsageStatusUnion) RawJSON() string { return u.JSON.raw }

func (r *BetaFallbackCreditUsageStatusUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Identifies one hop of a fallback transition.
type BetaFallbackInfo struct {
	// The model that will complete your prompt.
	//
	// See [models](https://docs.anthropic.com/en/docs/models-overview) for additional
	// details and options.
	Model Model `json:"model" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Model       respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaFallbackInfo) RawJSON() string { return r.JSON.raw }
func (r *BetaFallbackInfo) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Identifies one hop of a fallback transition.
//
// The property Model is required.
type BetaFallbackInfoParam struct {
	// The model that will complete your prompt.
	//
	// See [models](https://docs.anthropic.com/en/docs/models-overview) for additional
	// details and options.
	Model Model `json:"model,omitzero" api:"required"`
	paramObj
}

func (r BetaFallbackInfoParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaFallbackInfoParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaFallbackInfoParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Token usage for the fallback-model attempt of a server-side fallback request.
//
// Produced in place of a `message` entry for whichever hop served the response. A
// declined hop produces the existing `message` entry. Whether a fallback model
// served the response is signalled by the presence of this entry in
// `usage.iterations`.
type BetaFallbackMessageIterationUsage struct {
	// Breakdown of cached tokens by TTL
	CacheCreation BetaCacheCreation `json:"cache_creation" api:"required"`
	// The number of input tokens used to create the cache entry.
	CacheCreationInputTokens int64 `json:"cache_creation_input_tokens" api:"required"`
	// The number of input tokens read from the cache.
	CacheReadInputTokens int64 `json:"cache_read_input_tokens" api:"required"`
	// The number of input tokens which were used.
	InputTokens int64 `json:"input_tokens" api:"required"`
	// The model that will complete your prompt.
	//
	// See [models](https://docs.anthropic.com/en/docs/models-overview) for additional
	// details and options.
	Model Model `json:"model" api:"required"`
	// The number of output tokens which were used.
	OutputTokens int64 `json:"output_tokens" api:"required"`
	// Usage for the fallback-model attempt that served the response
	Type constant.FallbackMessage `json:"type" default:"fallback_message"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CacheCreation            respjson.Field
		CacheCreationInputTokens respjson.Field
		CacheReadInputTokens     respjson.Field
		InputTokens              respjson.Field
		Model                    respjson.Field
		OutputTokens             respjson.Field
		Type                     respjson.Field
		ExtraFields              map[string]respjson.Field
		raw                      string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaFallbackMessageIterationUsage) RawJSON() string { return r.JSON.raw }
func (r *BetaFallbackMessageIterationUsage) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// One entry in the `fallbacks` chain on a `/v1/messages` request.
//
// `model` is required. The override fields (`max_tokens`, `thinking`,
// `output_config`, and `speed`) set the corresponding parameter for this attempt
// only and are validated as if the request were made to `model`. Any other key is
// rejected at parse time.
//
// The property Model is required.
type BetaFallbackParam struct {
	// The model that will complete your prompt.
	//
	// See [models](https://docs.anthropic.com/en/docs/models-overview) for additional
	// details and options.
	Model     Model            `json:"model,omitzero" api:"required"`
	MaxTokens param.Opt[int64] `json:"max_tokens,omitzero"`
	// Inference speed mode. `fast` provides significantly faster output token
	// generation at premium pricing. Not all models support `fast`; invalid
	// combinations are rejected at create time.
	//
	// Any of "standard", "fast".
	Speed        BetaFallbackParamSpeed         `json:"speed,omitzero"`
	Thinking     BetaFallbackParamThinkingUnion `json:"thinking,omitzero"`
	OutputConfig BetaOutputConfigParam          `json:"output_config,omitzero"`
	ExtraFields  map[string]any                 `json:"-"`
	paramObj
}

func (r BetaFallbackParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaFallbackParam
	return param.MarshalWithExtras(r, (*shadow)(&r), r.ExtraFields)
}
func (r *BetaFallbackParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Inference speed mode. `fast` provides significantly faster output token
// generation at premium pricing. Not all models support `fast`; invalid
// combinations are rejected at create time.
type BetaFallbackParamSpeed string

const (
	BetaFallbackParamSpeedStandard BetaFallbackParamSpeed = "standard"
	BetaFallbackParamSpeedFast     BetaFallbackParamSpeed = "fast"
)

// Only one field can be non-zero.
//
// Use [param.IsOmitted] to confirm if a field is set.
type BetaFallbackParamThinkingUnion struct {
	OfEnabled  *BetaThinkingConfigEnabledParam  `json:",omitzero,inline"`
	OfDisabled *BetaThinkingConfigDisabledParam `json:",omitzero,inline"`
	OfAdaptive *BetaThinkingConfigAdaptiveParam `json:",omitzero,inline"`
	paramUnion
}

func (u BetaFallbackParamThinkingUnion) MarshalJSON() ([]byte, error) {
	return param.MarshalUnion(u, u.OfEnabled, u.OfDisabled, u.OfAdaptive)
}
func (u *BetaFallbackParamThinkingUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, u)
}

func (u *BetaFallbackParamThinkingUnion) asAny() any {
	if !param.IsOmitted(u.OfEnabled) {
		return u.OfEnabled
	} else if !param.IsOmitted(u.OfDisabled) {
		return u.OfDisabled
	} else if !param.IsOmitted(u.OfAdaptive) {
		return u.OfAdaptive
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaFallbackParamThinkingUnion) GetBudgetTokens() *int64 {
	if vt := u.OfEnabled; vt != nil {
		return &vt.BudgetTokens
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaFallbackParamThinkingUnion) GetType() *string {
	if vt := u.OfEnabled; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfDisabled; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfAdaptive; vt != nil {
		return (*string)(&vt.Type)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaFallbackParamThinkingUnion) GetDisplay() *string {
	if vt := u.OfEnabled; vt != nil {
		return (*string)(&vt.Display)
	} else if vt := u.OfAdaptive; vt != nil {
		return (*string)(&vt.Display)
	}
	return nil
}

// Returns a pointer to the underlying variant's BlockBinding property, if present.
func (u BetaFallbackParamThinkingUnion) GetBlockBinding() *BetaThinkingBlockBindingParam {
	if vt := u.OfEnabled; vt != nil {
		return &vt.BlockBinding
	} else if vt := u.OfAdaptive; vt != nil {
		return &vt.BlockBinding
	}
	return nil
}

func init() {
	apijson.RegisterUnion[BetaFallbackParamThinkingUnion](
		"type",
		apijson.Discriminator[BetaThinkingConfigEnabledParam]("enabled"),
		apijson.Discriminator[BetaThinkingConfigDisabledParam]("disabled"),
		apijson.Discriminator[BetaThinkingConfigAdaptiveParam]("adaptive"),
	)
}

// The `from` model declined for policy reasons.
type BetaFallbackRefusalTrigger struct {
	// The policy category that triggered a refusal.
	//
	// Any of "cyber", "bio", "frontier_llm", "reasoning_extraction", "general_harms".
	Category BetaFallbackRefusalTriggerCategory `json:"category" api:"required"`
	Type     constant.Refusal                   `json:"type" default:"refusal"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Category    respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaFallbackRefusalTrigger) RawJSON() string { return r.JSON.raw }
func (r *BetaFallbackRefusalTrigger) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The policy category that triggered a refusal.
type BetaFallbackRefusalTriggerCategory string

const (
	BetaFallbackRefusalTriggerCategoryCyber               BetaFallbackRefusalTriggerCategory = "cyber"
	BetaFallbackRefusalTriggerCategoryBio                 BetaFallbackRefusalTriggerCategory = "bio"
	BetaFallbackRefusalTriggerCategoryFrontierLLM         BetaFallbackRefusalTriggerCategory = "frontier_llm"
	BetaFallbackRefusalTriggerCategoryReasoningExtraction BetaFallbackRefusalTriggerCategory = "reasoning_extraction"
	BetaFallbackRefusalTriggerCategoryGeneralHarms        BetaFallbackRefusalTriggerCategory = "general_harms"
)

func BetaFallbacksParamOfDefault() BetaFallbacksParamUnion {
	return BetaFallbacksParamUnion{OfDefault: constant.ValueOf[constant.Default]()}
}

// Only one field can be non-zero.
//
// Use [param.IsOmitted] to confirm if a field is set.
type BetaFallbacksParamUnion struct {
	OfBetaFallbackArray []BetaFallbackParam `json:",omitzero,inline"`
	// Construct this variant with constant.ValueOf[constant.Default]()
	OfDefault constant.Default `json:",omitzero,inline"`
	paramUnion
}

func (u BetaFallbacksParamUnion) MarshalJSON() ([]byte, error) {
	return param.MarshalUnion(u, u.OfBetaFallbackArray, u.OfDefault)
}
func (u *BetaFallbacksParamUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, u)
}

func (u *BetaFallbacksParamUnion) asAny() any {
	if !param.IsOmitted(u.OfBetaFallbackArray) {
		return &u.OfBetaFallbackArray
	} else if !param.IsOmitted(u.OfDefault) {
		return &u.OfDefault
	}
	return nil
}

// The properties FileID, Type are required.
type BetaFileDocumentSourceParam struct {
	FileID string `json:"file_id" api:"required"`
	// This field can be elided, and will marshal its zero value as "file".
	Type constant.File `json:"type" default:"file"`
	paramObj
}

func (r BetaFileDocumentSourceParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaFileDocumentSourceParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaFileDocumentSourceParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties FileID, Type are required.
type BetaFileImageSourceParam struct {
	FileID string `json:"file_id" api:"required"`
	// This field can be elided, and will marshal its zero value as "file".
	Type constant.File `json:"type" default:"file"`
	paramObj
}

func (r BetaFileImageSourceParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaFileImageSourceParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaFileImageSourceParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties Source, Type are required.
type BetaImageBlockParam struct {
	Source BetaImageBlockParamSourceUnion `json:"source,omitzero" api:"required"`
	// Create a cache control breakpoint at this content block.
	CacheControl BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	// Configures the transformations the server applies to this image before the model
	// observes it. Each key names a condition the server transforms images for; its
	// value selects the transformation applied. Omitted keys keep their default
	// behavior, and an empty object is equivalent to omitting the field.
	Transformations BetaImageTransformationsParam `json:"transformations,omitzero"`
	// This field can be elided, and will marshal its zero value as "image".
	Type constant.Image `json:"type" default:"image"`
	paramObj
}

func (r BetaImageBlockParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaImageBlockParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaImageBlockParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Only one field can be non-zero.
//
// Use [param.IsOmitted] to confirm if a field is set.
type BetaImageBlockParamSourceUnion struct {
	OfBase64 *BetaBase64ImageSourceParam `json:",omitzero,inline"`
	OfURL    *BetaURLImageSourceParam    `json:",omitzero,inline"`
	OfFile   *BetaFileImageSourceParam   `json:",omitzero,inline"`
	paramUnion
}

func (u BetaImageBlockParamSourceUnion) MarshalJSON() ([]byte, error) {
	return param.MarshalUnion(u, u.OfBase64, u.OfURL, u.OfFile)
}
func (u *BetaImageBlockParamSourceUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, u)
}

func (u *BetaImageBlockParamSourceUnion) asAny() any {
	if !param.IsOmitted(u.OfBase64) {
		return u.OfBase64
	} else if !param.IsOmitted(u.OfURL) {
		return u.OfURL
	} else if !param.IsOmitted(u.OfFile) {
		return u.OfFile
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaImageBlockParamSourceUnion) GetData() *string {
	if vt := u.OfBase64; vt != nil {
		return &vt.Data
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaImageBlockParamSourceUnion) GetMediaType() *string {
	if vt := u.OfBase64; vt != nil {
		return (*string)(&vt.MediaType)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaImageBlockParamSourceUnion) GetURL() *string {
	if vt := u.OfURL; vt != nil {
		return &vt.URL
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaImageBlockParamSourceUnion) GetFileID() *string {
	if vt := u.OfFile; vt != nil {
		return &vt.FileID
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaImageBlockParamSourceUnion) GetType() *string {
	if vt := u.OfBase64; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfURL; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfFile; vt != nil {
		return (*string)(&vt.Type)
	}
	return nil
}

func init() {
	apijson.RegisterUnion[BetaImageBlockParamSourceUnion](
		"type",
		apijson.Discriminator[BetaBase64ImageSourceParam]("base64"),
		apijson.Discriminator[BetaURLImageSourceParam]("url"),
		apijson.Discriminator[BetaFileImageSourceParam]("file"),
	)
}

// Configures the transformations the server applies to this image before the model
// observes it. Each key names a condition the server transforms images for; its
// value selects the transformation applied. Omitted keys keep their default
// behavior, and an empty object is equivalent to omitting the field.
type BetaImageTransformationsParam struct {
	// What the server does when this image exceeds the model's maximum image size.
	// `"downsize"` (the default) scales the image down to fit, which changes the
	// dimensions the model observes without telling you. `"error"` instead rejects the
	// request with a 400 error naming the image's dimensions and the largest
	// dimensions that fit, so you can scale the image deliberately — your image is
	// never silently scaled down.
	//
	// Any of "downsize", "error".
	OversizedImage BetaImageTransformationsParamOversizedImage `json:"oversized_image,omitzero"`
	paramObj
}

func (r BetaImageTransformationsParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaImageTransformationsParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaImageTransformationsParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// What the server does when this image exceeds the model's maximum image size.
// `"downsize"` (the default) scales the image down to fit, which changes the
// dimensions the model observes without telling you. `"error"` instead rejects the
// request with a 400 error naming the image's dimensions and the largest
// dimensions that fit, so you can scale the image deliberately — your image is
// never silently scaled down.
type BetaImageTransformationsParamOversizedImage string

const (
	BetaImageTransformationsParamOversizedImageDownsize BetaImageTransformationsParamOversizedImage = "downsize"
	BetaImageTransformationsParamOversizedImageError    BetaImageTransformationsParamOversizedImage = "error"
)

type BetaInputJSONDelta struct {
	PartialJSON string                  `json:"partial_json" api:"required"`
	Type        constant.InputJSONDelta `json:"type" default:"input_json_delta"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		PartialJSON respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaInputJSONDelta) RawJSON() string { return r.JSON.raw }
func (r *BetaInputJSONDelta) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties Type, Value are required.
type BetaInputTokensClearAtLeastParam struct {
	Value int64 `json:"value" api:"required"`
	// This field can be elided, and will marshal its zero value as "input_tokens".
	Type constant.InputTokens `json:"type" default:"input_tokens"`
	paramObj
}

func (r BetaInputTokensClearAtLeastParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaInputTokensClearAtLeastParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaInputTokensClearAtLeastParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties Type, Value are required.
type BetaInputTokensTriggerParam struct {
	Value int64 `json:"value" api:"required"`
	// This field can be elided, and will marshal its zero value as "input_tokens".
	Type constant.InputTokens `json:"type" default:"input_tokens"`
	paramObj
}

func (r BetaInputTokensTriggerParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaInputTokensTriggerParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaInputTokensTriggerParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaIterationsUsage []BetaIterationsUsageItemUnion

// BetaIterationsUsageItemUnion contains all possible properties and values from
// [BetaMessageIterationUsage], [BetaCompactionIterationUsage],
// [BetaAdvisorMessageIterationUsage], [BetaFallbackMessageIterationUsage].
//
// Use the [BetaIterationsUsageItemUnion.AsAny] method to switch on the variant.
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
type BetaIterationsUsageItemUnion struct {
	// This field is from variant [BetaMessageIterationUsage].
	CacheCreation            BetaCacheCreation `json:"cache_creation"`
	CacheCreationInputTokens int64             `json:"cache_creation_input_tokens"`
	CacheReadInputTokens     int64             `json:"cache_read_input_tokens"`
	InputTokens              int64             `json:"input_tokens"`
	// This field is from variant [BetaMessageIterationUsage].
	Model        Model `json:"model"`
	OutputTokens int64 `json:"output_tokens"`
	// Any of "message", "compaction", "advisor_message", "fallback_message".
	Type string `json:"type"`
	JSON struct {
		CacheCreation            respjson.Field
		CacheCreationInputTokens respjson.Field
		CacheReadInputTokens     respjson.Field
		InputTokens              respjson.Field
		Model                    respjson.Field
		OutputTokens             respjson.Field
		Type                     respjson.Field
		raw                      string
	} `json:"-"`
}

// anyBetaIterationsUsageItem is implemented by each variant of
// [BetaIterationsUsageItemUnion] to add type safety for the return type of
// [BetaIterationsUsageItemUnion.AsAny]
type anyBetaIterationsUsageItem interface {
	implBetaIterationsUsageItemUnion()
}

func (BetaMessageIterationUsage) implBetaIterationsUsageItemUnion()         {}
func (BetaCompactionIterationUsage) implBetaIterationsUsageItemUnion()      {}
func (BetaAdvisorMessageIterationUsage) implBetaIterationsUsageItemUnion()  {}
func (BetaFallbackMessageIterationUsage) implBetaIterationsUsageItemUnion() {}

// Use the following switch statement to find the correct variant
//
//	switch variant := BetaIterationsUsageItemUnion.AsAny().(type) {
//	case anthropic.BetaMessageIterationUsage:
//	case anthropic.BetaCompactionIterationUsage:
//	case anthropic.BetaAdvisorMessageIterationUsage:
//	case anthropic.BetaFallbackMessageIterationUsage:
//	default:
//	  fmt.Errorf("no variant present")
//	}
func (u BetaIterationsUsageItemUnion) AsAny() anyBetaIterationsUsageItem {
	switch u.Type {
	case "message":
		return u.AsMessage()
	case "compaction":
		return u.AsCompaction()
	case "advisor_message":
		return u.AsAdvisorMessage()
	case "fallback_message":
		return u.AsFallbackMessage()
	}
	return nil
}

func (u BetaIterationsUsageItemUnion) AsMessage() (v BetaMessageIterationUsage) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaIterationsUsageItemUnion) AsCompaction() (v BetaCompactionIterationUsage) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaIterationsUsageItemUnion) AsAdvisorMessage() (v BetaAdvisorMessageIterationUsage) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaIterationsUsageItemUnion) AsFallbackMessage() (v BetaFallbackMessageIterationUsage) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u BetaIterationsUsageItemUnion) RawJSON() string { return u.JSON.raw }

func (r *BetaIterationsUsageItemUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// BetaJSONOutputFormatParam configures JSON structured output for a message request.
// The preferred usage is to pass a pointer to a Go struct as Schema. The SDK will
// auto-generate the JSON schema on the wire and auto-parse the response back into
// the struct after the request completes:
//
//	var result MyStruct
//	msg, _ := client.Beta.Messages.New(ctx, anthropic.BetaMessageNewParams{
//	    OutputFormat: anthropic.BetaJSONOutputFormatParam{Schema: &result},
//	    ...
//	})
//
// For streaming, call ParseOutput after accumulating the message:
//
//	msg.ParseOutput(&result)
//
// The properties Schema, Type are required.
type BetaJSONOutputFormatParam struct {
	// The JSON schema of the format.
	//
	// This can be a map[string]any, json.RawMessage, or a pointer to a Go struct.
	// When a struct pointer is provided, the SDK automatically generates the JSON
	// schema on the wire and can auto-parse the response back into the struct.
	// A struct pointer is preferred over map[string]any because it provides
	// auto-parsing and type safety. If you already have a JSON schema as bytes,
	// use json.RawMessage to avoid unnecessary marshaling overhead.
	//
	// Set the schema on either BetaMessageNewParams.OutputFormat or
	// BetaMessageNewParams.OutputConfig.Format, not both. If both carry a struct
	// pointer, OutputFormat wins for auto-parse.
	Schema any `json:"schema,omitzero" api:"required"`
	// This field can be elided, and will marshal its zero value as "json_schema".
	Type constant.JSONSchema `json:"type" default:"json_schema"`
	paramObj
}

func (r BetaJSONOutputFormatParam) MarshalJSON() (data []byte, err error) {
	// Convert struct pointers and maps to json.RawMessage so the wire
	// payload contains a JSON schema, not the struct's field values.
	// Value receiver keeps the caller's Schema intact for auto-parse.
	if r.Schema != nil {
		raw, e := schemaToRaw(r.Schema)
		if e != nil {
			return nil, e
		}
		if raw != nil {
			r.Schema = raw
		}
	}
	type shadow BetaJSONOutputFormatParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaJSONOutputFormatParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Configuration for a specific tool in an MCP toolset.
type BetaMCPToolConfigParam struct {
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	Enabled      param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaMCPToolConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaMCPToolConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaMCPToolConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Default configuration for tools in an MCP toolset.
type BetaMCPToolDefaultConfigParam struct {
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	Enabled      param.Opt[bool] `json:"enabled,omitzero"`
	paramObj
}

func (r BetaMCPToolDefaultConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaMCPToolDefaultConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaMCPToolDefaultConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaMCPToolResultBlock struct {
	Content   BetaMCPToolResultBlockContentUnion `json:"content" api:"required"`
	IsError   bool                               `json:"is_error" api:"required"`
	ToolUseID string                             `json:"tool_use_id" api:"required"`
	Type      constant.MCPToolResult             `json:"type" default:"mcp_tool_result"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Content     respjson.Field
		IsError     respjson.Field
		ToolUseID   respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaMCPToolResultBlock) RawJSON() string { return r.JSON.raw }
func (r *BetaMCPToolResultBlock) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// BetaMCPToolResultBlockContentUnion contains all possible properties and values
// from [string], [[]BetaTextBlock].
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
//
// If the underlying value is not a json object, one of the following properties
// will be valid: OfString OfBetaMCPToolResultBlockContent]
type BetaMCPToolResultBlockContentUnion struct {
	// This field will be present if the value is a [string] instead of an object.
	OfString string `json:",inline"`
	// This field will be present if the value is a [[]BetaTextBlock] instead of an
	// object.
	OfBetaMCPToolResultBlockContent []BetaTextBlock `json:",inline"`
	JSON                            struct {
		OfString                        respjson.Field
		OfBetaMCPToolResultBlockContent respjson.Field
		raw                             string
	} `json:"-"`
}

func (u BetaMCPToolResultBlockContentUnion) AsString() (v string) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaMCPToolResultBlockContentUnion) AsBetaMCPToolResultBlockContent() (v []BetaTextBlock) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u BetaMCPToolResultBlockContentUnion) RawJSON() string { return u.JSON.raw }

func (r *BetaMCPToolResultBlockContentUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaMCPToolUseBlock struct {
	ID    string `json:"id" api:"required"`
	Input any    `json:"input" api:"required"`
	// The name of the MCP tool
	Name string `json:"name" api:"required"`
	// The name of the MCP server
	ServerName string              `json:"server_name" api:"required"`
	Type       constant.MCPToolUse `json:"type" default:"mcp_tool_use"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Input       respjson.Field
		Name        respjson.Field
		ServerName  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaMCPToolUseBlock) RawJSON() string { return r.JSON.raw }
func (r *BetaMCPToolUseBlock) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties ID, Input, Name, ServerName, Type are required.
type BetaMCPToolUseBlockParam struct {
	ID    string `json:"id" api:"required"`
	Input any    `json:"input,omitzero" api:"required"`
	Name  string `json:"name" api:"required"`
	// The name of the MCP server
	ServerName string `json:"server_name" api:"required"`
	// Create a cache control breakpoint at this content block.
	CacheControl BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	// This field can be elided, and will marshal its zero value as "mcp_tool_use".
	Type constant.MCPToolUse `json:"type" default:"mcp_tool_use"`
	paramObj
}

func (r BetaMCPToolUseBlockParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaMCPToolUseBlockParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaMCPToolUseBlockParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Configuration for a group of tools from an MCP server.
//
// Allows configuring enabled status and defer_loading for all tools from an MCP
// server, with optional per-tool overrides.
//
// The properties MCPServerName, Type are required.
type BetaMCPToolsetParam struct {
	// Name of the MCP server to configure tools for
	MCPServerName string `json:"mcp_server_name" api:"required"`
	// Configuration overrides for specific tools, keyed by tool name
	Configs map[string]BetaMCPToolConfigParam `json:"configs,omitzero"`
	// Create a cache control breakpoint at this content block.
	CacheControl BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	// Default configuration applied to all tools from this server
	DefaultConfig BetaMCPToolDefaultConfigParam `json:"default_config,omitzero"`
	// This field can be elided, and will marshal its zero value as "mcp_toolset".
	Type constant.MCPToolset `json:"type" default:"mcp_toolset"`
	paramObj
}

func (r BetaMCPToolsetParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaMCPToolsetParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaMCPToolsetParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties Name, Type are required.
type BetaMemoryTool20250818Param struct {
	// If true, tool will not be included in initial system prompt. Only loaded when
	// returned via tool_reference from tool search.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// When true, guarantees schema validation on tool names and inputs
	Strict param.Opt[bool] `json:"strict,omitzero"`
	// Any of "direct", "code_execution_20250825", "code_execution_20260120",
	// "code_execution_20260521".
	AllowedCallers []string `json:"allowed_callers,omitzero"`
	// Create a cache control breakpoint at this content block.
	CacheControl  BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	InputExamples []map[string]any               `json:"input_examples,omitzero"`
	// Name of the tool.
	//
	// This is how the tool will be called by the model and in `tool_use` blocks.
	//
	// This field can be elided, and will marshal its zero value as "memory".
	Name constant.Memory `json:"name" default:"memory"`
	// This field can be elided, and will marshal its zero value as "memory_20250818".
	Type constant.Memory20250818 `json:"type" default:"memory_20250818"`
	paramObj
}

func (r BetaMemoryTool20250818Param) MarshalJSON() (data []byte, err error) {
	type shadow BetaMemoryTool20250818Param
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaMemoryTool20250818Param) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// BetaMemoryTool20250818CommandUnion contains all possible properties and values
// from [BetaMemoryTool20250818ViewCommand], [BetaMemoryTool20250818CreateCommand],
// [BetaMemoryTool20250818StrReplaceCommand],
// [BetaMemoryTool20250818InsertCommand], [BetaMemoryTool20250818DeleteCommand],
// [BetaMemoryTool20250818RenameCommand].
//
// Use the [BetaMemoryTool20250818CommandUnion.AsAny] method to switch on the
// variant.
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
type BetaMemoryTool20250818CommandUnion struct {
	// Any of "view", "create", "str_replace", "insert", "delete", "rename".
	Command string `json:"command"`
	Path    string `json:"path"`
	// This field is from variant [BetaMemoryTool20250818ViewCommand].
	ViewRange []int64 `json:"view_range"`
	// This field is from variant [BetaMemoryTool20250818CreateCommand].
	FileText string `json:"file_text"`
	// This field is from variant [BetaMemoryTool20250818StrReplaceCommand].
	NewStr string `json:"new_str"`
	// This field is from variant [BetaMemoryTool20250818StrReplaceCommand].
	OldStr string `json:"old_str"`
	// This field is from variant [BetaMemoryTool20250818InsertCommand].
	InsertLine int64 `json:"insert_line"`
	// This field is from variant [BetaMemoryTool20250818InsertCommand].
	InsertText string `json:"insert_text"`
	// This field is from variant [BetaMemoryTool20250818RenameCommand].
	NewPath string `json:"new_path"`
	// This field is from variant [BetaMemoryTool20250818RenameCommand].
	OldPath string `json:"old_path"`
	JSON    struct {
		Command    respjson.Field
		Path       respjson.Field
		ViewRange  respjson.Field
		FileText   respjson.Field
		NewStr     respjson.Field
		OldStr     respjson.Field
		InsertLine respjson.Field
		InsertText respjson.Field
		NewPath    respjson.Field
		OldPath    respjson.Field
		raw        string
	} `json:"-"`
}

// anyBetaMemoryTool20250818Command is implemented by each variant of
// [BetaMemoryTool20250818CommandUnion] to add type safety for the return type of
// [BetaMemoryTool20250818CommandUnion.AsAny]
type anyBetaMemoryTool20250818Command interface {
	implBetaMemoryTool20250818CommandUnion()
}

func (BetaMemoryTool20250818ViewCommand) implBetaMemoryTool20250818CommandUnion()       {}
func (BetaMemoryTool20250818CreateCommand) implBetaMemoryTool20250818CommandUnion()     {}
func (BetaMemoryTool20250818StrReplaceCommand) implBetaMemoryTool20250818CommandUnion() {}
func (BetaMemoryTool20250818InsertCommand) implBetaMemoryTool20250818CommandUnion()     {}
func (BetaMemoryTool20250818DeleteCommand) implBetaMemoryTool20250818CommandUnion()     {}
func (BetaMemoryTool20250818RenameCommand) implBetaMemoryTool20250818CommandUnion()     {}

// Use the following switch statement to find the correct variant
//
//	switch variant := BetaMemoryTool20250818CommandUnion.AsAny().(type) {
//	case anthropic.BetaMemoryTool20250818ViewCommand:
//	case anthropic.BetaMemoryTool20250818CreateCommand:
//	case anthropic.BetaMemoryTool20250818StrReplaceCommand:
//	case anthropic.BetaMemoryTool20250818InsertCommand:
//	case anthropic.BetaMemoryTool20250818DeleteCommand:
//	case anthropic.BetaMemoryTool20250818RenameCommand:
//	default:
//	  fmt.Errorf("no variant present")
//	}
func (u BetaMemoryTool20250818CommandUnion) AsAny() anyBetaMemoryTool20250818Command {
	switch u.Command {
	case "view":
		return u.AsView()
	case "create":
		return u.AsCreate()
	case "str_replace":
		return u.AsStrReplace()
	case "insert":
		return u.AsInsert()
	case "delete":
		return u.AsDelete()
	case "rename":
		return u.AsRename()
	}
	return nil
}

func (u BetaMemoryTool20250818CommandUnion) AsView() (v BetaMemoryTool20250818ViewCommand) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaMemoryTool20250818CommandUnion) AsCreate() (v BetaMemoryTool20250818CreateCommand) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaMemoryTool20250818CommandUnion) AsStrReplace() (v BetaMemoryTool20250818StrReplaceCommand) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaMemoryTool20250818CommandUnion) AsInsert() (v BetaMemoryTool20250818InsertCommand) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaMemoryTool20250818CommandUnion) AsDelete() (v BetaMemoryTool20250818DeleteCommand) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaMemoryTool20250818CommandUnion) AsRename() (v BetaMemoryTool20250818RenameCommand) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u BetaMemoryTool20250818CommandUnion) RawJSON() string { return u.JSON.raw }

func (r *BetaMemoryTool20250818CommandUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaMemoryTool20250818CreateCommand struct {
	// Command type identifier
	Command constant.Create `json:"command" default:"create"`
	// Content to write to the file
	FileText string `json:"file_text" api:"required"`
	// Path where the file should be created
	Path string `json:"path" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Command     respjson.Field
		FileText    respjson.Field
		Path        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaMemoryTool20250818CreateCommand) RawJSON() string { return r.JSON.raw }
func (r *BetaMemoryTool20250818CreateCommand) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaMemoryTool20250818DeleteCommand struct {
	// Command type identifier
	Command constant.Delete `json:"command" default:"delete"`
	// Path to the file or directory to delete
	Path string `json:"path" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Command     respjson.Field
		Path        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaMemoryTool20250818DeleteCommand) RawJSON() string { return r.JSON.raw }
func (r *BetaMemoryTool20250818DeleteCommand) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaMemoryTool20250818InsertCommand struct {
	// Command type identifier
	Command constant.Insert `json:"command" default:"insert"`
	// Line number where text should be inserted
	InsertLine int64 `json:"insert_line" api:"required"`
	// Text to insert at the specified line
	InsertText string `json:"insert_text" api:"required"`
	// Path to the file where text should be inserted
	Path string `json:"path" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Command     respjson.Field
		InsertLine  respjson.Field
		InsertText  respjson.Field
		Path        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaMemoryTool20250818InsertCommand) RawJSON() string { return r.JSON.raw }
func (r *BetaMemoryTool20250818InsertCommand) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaMemoryTool20250818RenameCommand struct {
	// Command type identifier
	Command constant.Rename `json:"command" default:"rename"`
	// New path for the file or directory
	NewPath string `json:"new_path" api:"required"`
	// Current path of the file or directory
	OldPath string `json:"old_path" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Command     respjson.Field
		NewPath     respjson.Field
		OldPath     respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaMemoryTool20250818RenameCommand) RawJSON() string { return r.JSON.raw }
func (r *BetaMemoryTool20250818RenameCommand) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaMemoryTool20250818StrReplaceCommand struct {
	// Command type identifier
	Command constant.StrReplace `json:"command" default:"str_replace"`
	// Text to replace with
	NewStr string `json:"new_str" api:"required"`
	// Text to search for and replace
	OldStr string `json:"old_str" api:"required"`
	// Path to the file where text should be replaced
	Path string `json:"path" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Command     respjson.Field
		NewStr      respjson.Field
		OldStr      respjson.Field
		Path        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaMemoryTool20250818StrReplaceCommand) RawJSON() string { return r.JSON.raw }
func (r *BetaMemoryTool20250818StrReplaceCommand) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaMemoryTool20250818ViewCommand struct {
	// Command type identifier
	Command constant.View `json:"command" default:"view"`
	// Path to directory or file to view
	Path string `json:"path" api:"required"`
	// Optional line range for viewing specific lines
	ViewRange []int64 `json:"view_range"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Command     respjson.Field
		Path        respjson.Field
		ViewRange   respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaMemoryTool20250818ViewCommand) RawJSON() string { return r.JSON.raw }
func (r *BetaMemoryTool20250818ViewCommand) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaMessage struct {
	// Unique object identifier.
	//
	// The format and length of IDs may change over time.
	ID string `json:"id" api:"required"`
	// Information about the container used in the request (for the code execution
	// tool)
	Container BetaContainer `json:"container" api:"required"`
	// Content generated by the model.
	//
	// This is an array of content blocks, each of which has a `type` that determines
	// its shape.
	//
	// Example:
	//
	// ```json
	// [{ "type": "text", "text": "Hi, I'm Claude." }]
	// ```
	//
	// If the request input `messages` ended with an `assistant` turn, then the
	// response `content` will continue directly from that last turn. You can use this
	// to constrain the model's output.
	//
	// For example, if the input `messages` were:
	//
	// ```json
	// [
	//
	//	{
	//	  "role": "user",
	//	  "content": "What's the Greek name for Sun? (A) Sol (B) Helios (C) Sun"
	//	},
	//	{ "role": "assistant", "content": "The best answer is (" }
	//
	// ]
	// ```
	//
	// Then the response `content` might be:
	//
	// ```json
	// [{ "type": "text", "text": "B)" }]
	// ```
	Content []BetaContentBlockUnion `json:"content" api:"required"`
	// Context management response.
	//
	// Information about context management strategies applied during the request.
	ContextManagement BetaContextManagementResponse `json:"context_management" api:"required"`
	// Response envelope for request-level diagnostics. Present (possibly null)
	// whenever the caller supplied `diagnostics` on the request.
	Diagnostics BetaDiagnostics `json:"diagnostics" api:"required"`
	// The model that will complete your prompt.
	//
	// See [models](https://docs.anthropic.com/en/docs/models-overview) for additional
	// details and options.
	Model Model `json:"model" api:"required"`
	// Conversational role of the generated message.
	//
	// This will always be `"assistant"`.
	Role constant.Assistant `json:"role" default:"assistant"`
	// Structured information about a refusal.
	StopDetails BetaRefusalStopDetails `json:"stop_details" api:"required"`
	// The reason that we stopped.
	//
	// This may be one the following values:
	//
	//   - `"end_turn"`: the model reached a natural stopping point
	//   - `"max_tokens"`: we exceeded the requested `max_tokens` or the model's maximum
	//   - `"stop_sequence"`: one of your provided custom `stop_sequences` was generated
	//   - `"tool_use"`: the model invoked one or more tools
	//   - `"pause_turn"`: we paused a long-running turn. You may provide the response
	//     back as-is in a subsequent request to let the model continue.
	//   - `"refusal"`: when streaming classifiers intervene to handle potential policy
	//     violations
	//   - `"model_context_window_exceeded"`: we exceeded the model's context window
	//
	// In non-streaming mode this value is always non-null. In streaming mode, it is
	// null in the `message_start` event and non-null otherwise.
	//
	// Any of "end_turn", "max_tokens", "stop_sequence", "tool_use", "pause_turn",
	// "compaction", "refusal", "model_context_window_exceeded".
	StopReason BetaStopReason `json:"stop_reason" api:"required"`
	// Which custom stop sequence was generated, if any.
	//
	// This value will be a non-null string if one of your custom stop sequences was
	// generated.
	StopSequence string `json:"stop_sequence" api:"required"`
	// Object type.
	//
	// For Messages, this is always `"message"`.
	Type constant.Message `json:"type" default:"message"`
	// Billing and rate-limit usage.
	//
	// Anthropic's API bills and rate-limits by token counts, as tokens represent the
	// underlying cost to our systems.
	//
	// Under the hood, the API transforms requests into a format suitable for the
	// model. The model's output then goes through a parsing stage before becoming an
	// API response. As a result, the token counts in `usage` will not match one-to-one
	// with the exact visible content of an API request or response.
	//
	// For example, `output_tokens` will be non-zero, even for an empty string response
	// from Claude.
	//
	// Total input tokens in a request is the summation of `input_tokens`,
	// `cache_creation_input_tokens`, and `cache_read_input_tokens`.
	Usage BetaUsage `json:"usage" api:"required"`
	// Changes the API made to the request's input before showing it to the model: one
	// entry per change, in request order. Today the only entry type is
	// `thinking_dropped` — a `thinking`, `redacted_thinking` or `connector_text` block
	// from the request's `messages` that was removed from the prompt instead of being
	// shown to the model because it failed a binding check. More entry types may be
	// added over time; ignore types you do not recognize.
	//
	// Requires `anthropic-beta: thinking-binding-controls-2026-08-01`. Present on
	// every such response from a model that supports extended thinking, as `[]` when
	// nothing was changed; without the beta, blocks are removed all the same but
	// nothing is reported. Removed blocks contribute nothing to `usage.input_tokens`.
	// When streaming, the array is final in `message_start`; the final `message_delta`
	// event carries it only when a server-side model fallback happened mid-stream, in
	// which case it holds the serving model's entries and replaces the one in
	// `message_start`.
	InputTransformations []BetaThinkingDroppedInputTransformation `json:"input_transformations" api:"nullable"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID                   respjson.Field
		Container            respjson.Field
		Content              respjson.Field
		ContextManagement    respjson.Field
		Diagnostics          respjson.Field
		Model                respjson.Field
		Role                 respjson.Field
		StopDetails          respjson.Field
		StopReason           respjson.Field
		StopSequence         respjson.Field
		Type                 respjson.Field
		Usage                respjson.Field
		InputTransformations respjson.Field
		ExtraFields          map[string]respjson.Field
		raw                  string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaMessage) RawJSON() string { return r.JSON.raw }
func (r *BetaMessage) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaMessageDeltaUsage struct {
	// The cumulative number of input tokens used to create the cache entry.
	CacheCreationInputTokens int64 `json:"cache_creation_input_tokens" api:"required"`
	// The cumulative number of input tokens read from the cache.
	CacheReadInputTokens int64 `json:"cache_read_input_tokens" api:"required"`
	// Outcome of the `fallback_credit_token` presented on this request.
	FallbackCredit BetaFallbackCreditUsage `json:"fallback_credit" api:"required"`
	// The cumulative number of input tokens which were used.
	InputTokens int64 `json:"input_tokens" api:"required"`
	// Per-iteration token usage breakdown.
	//
	// Each entry represents one sampling iteration, with its own input/output token
	// counts and cache statistics, discriminated by `type`. For `message` entries
	// (model sampling iterations, such as the turns of a server-side tool use loop),
	// this allows you to:
	//
	// - Determine which iterations exceeded long context thresholds (>=200k tokens)
	// - Calculate the context window size from the last `message` entry
	// - Understand token accumulation across server-side tool use loops
	//
	// A `compaction` entry reports the token usage of the compaction operation itself
	// — the server-side request that summarizes the context being closed — NOT the
	// size of the context that was compacted away, and its token counts can be much
	// smaller than that closed context (for example, a compaction that closes a
	// ~200k-token context can report only a few thousand tokens). Do not derive the
	// context window size from a `compaction` entry, even when it is the last entry. A
	// `compaction` entry's tokens are not included in the top-level `usage` fields.
	// When an input-token trigger is in effect (the default — 150,000 tokens unless
	// configured otherwise), each `compaction` entry closes a context that had reached
	// at least that threshold, though the context can exceed it by the final
	// iteration's output and tool results.
	Iterations BetaIterationsUsage `json:"iterations" api:"required"`
	// The cumulative number of output tokens which were used.
	OutputTokens int64 `json:"output_tokens" api:"required"`
	// Breakdown of output tokens by category.
	//
	// `output_tokens` remains the inclusive, authoritative total used for billing.
	// This object provides a read-only decomposition for observability — for example,
	// how many of the billed output tokens were spent on internal reasoning that may
	// have been summarized before being returned to you.
	OutputTokensDetails BetaOutputTokensDetails `json:"output_tokens_details" api:"required"`
	// The number of server tool requests.
	ServerToolUse BetaServerToolUsage `json:"server_tool_use" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CacheCreationInputTokens respjson.Field
		CacheReadInputTokens     respjson.Field
		FallbackCredit           respjson.Field
		InputTokens              respjson.Field
		Iterations               respjson.Field
		OutputTokens             respjson.Field
		OutputTokensDetails      respjson.Field
		ServerToolUse            respjson.Field
		ExtraFields              map[string]respjson.Field
		raw                      string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaMessageDeltaUsage) RawJSON() string { return r.JSON.raw }
func (r *BetaMessageDeltaUsage) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Token usage for a sampling iteration.
type BetaMessageIterationUsage struct {
	// Breakdown of cached tokens by TTL
	CacheCreation BetaCacheCreation `json:"cache_creation" api:"required"`
	// The number of input tokens used to create the cache entry.
	CacheCreationInputTokens int64 `json:"cache_creation_input_tokens" api:"required"`
	// The number of input tokens read from the cache.
	CacheReadInputTokens int64 `json:"cache_read_input_tokens" api:"required"`
	// The number of input tokens which were used.
	InputTokens int64 `json:"input_tokens" api:"required"`
	// The model that will complete your prompt.
	//
	// See [models](https://docs.anthropic.com/en/docs/models-overview) for additional
	// details and options.
	Model Model `json:"model" api:"required"`
	// The number of output tokens which were used.
	OutputTokens int64 `json:"output_tokens" api:"required"`
	// Usage for a sampling iteration
	Type constant.Message `json:"type" default:"message"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CacheCreation            respjson.Field
		CacheCreationInputTokens respjson.Field
		CacheReadInputTokens     respjson.Field
		InputTokens              respjson.Field
		Model                    respjson.Field
		OutputTokens             respjson.Field
		Type                     respjson.Field
		ExtraFields              map[string]respjson.Field
		raw                      string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaMessageIterationUsage) RawJSON() string { return r.JSON.raw }
func (r *BetaMessageIterationUsage) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties Content, Role are required.
type BetaMessageParam struct {
	Content []BetaContentBlockParamUnion `json:"content,omitzero" api:"required"`
	// Any of "user", "assistant", "system".
	Role BetaMessageParamRole `json:"role,omitzero" api:"required"`
	// How long this system message's text stays in front of the model. `"never"` (the
	// default) renders it on every request that includes it. `"next_user_message"`
	// renders it only for the user turn it follows: once a later `role: "user"`
	// message exists in `messages` the message stays in the array (send it unchanged)
	// but is no longer shown to the model. Only permitted on `role: "system"`
	// messages.
	//
	// Any of "next_user_message", "never".
	ClearAt BetaMessageParamClearAt `json:"clear_at,omitzero"`
	// Per-message output configuration on a role:"system" input message.
	//
	// Fields here apply per-turn; `format` remains top-level only. An empty `{}` is
	// accepted on a message that carries content; a message with neither content nor
	// output_config fields is rejected.
	OutputConfig BetaSystemMessageOutputConfigParam `json:"output_config,omitzero"`
	paramObj
}

func NewBetaUserMessage(blocks ...BetaContentBlockParamUnion) BetaMessageParam {
	return BetaMessageParam{
		Role:    BetaMessageParamRoleUser,
		Content: blocks,
	}
}

// NewBetaSystemMessage builds a role:"system" message carrying a per-message
// output config. `content` is required on the wire, so nil becomes an empty slice.
func NewBetaSystemMessage(outputConfig BetaSystemMessageOutputConfigParam, blocks ...BetaContentBlockParamUnion) BetaMessageParam {
	if blocks == nil {
		blocks = []BetaContentBlockParamUnion{}
	}
	return BetaMessageParam{
		Role:         BetaMessageParamRoleSystem,
		Content:      blocks,
		OutputConfig: outputConfig,
	}
}

func (r BetaMessageParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaMessageParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaMessageParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaMessageParamRole string

const (
	BetaMessageParamRoleUser      BetaMessageParamRole = "user"
	BetaMessageParamRoleAssistant BetaMessageParamRole = "assistant"
	BetaMessageParamRoleSystem    BetaMessageParamRole = "system"
)

// How long this system message's text stays in front of the model. `"never"` (the
// default) renders it on every request that includes it. `"next_user_message"`
// renders it only for the user turn it follows: once a later `role: "user"`
// message exists in `messages` the message stays in the array (send it unchanged)
// but is no longer shown to the model. Only permitted on `role: "system"`
// messages.
type BetaMessageParamClearAt string

const (
	BetaMessageParamClearAtNextUserMessage BetaMessageParamClearAt = "next_user_message"
	BetaMessageParamClearAtNever           BetaMessageParamClearAt = "never"
)

type BetaMessageTokensCount struct {
	// Information about context management applied to the message.
	ContextManagement BetaCountTokensContextManagementResponse `json:"context_management" api:"required"`
	// The total number of tokens across the provided list of messages, system prompt,
	// and tools.
	InputTokens int64 `json:"input_tokens" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ContextManagement respjson.Field
		InputTokens       respjson.Field
		ExtraFields       map[string]respjson.Field
		raw               string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaMessageTokensCount) RawJSON() string { return r.JSON.raw }
func (r *BetaMessageTokensCount) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaMetadataParam struct {
	// An external identifier for the user who is associated with the request.
	//
	// This should be a uuid, hash value, or other opaque identifier. Anthropic may use
	// this id to help detect abuse. Do not include any identifying information such as
	// name, email address, or phone number.
	UserID param.Opt[string] `json:"user_id,omitzero"`
	paramObj
}

func (r BetaMetadataParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaMetadataParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaMetadataParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaOutputConfigParam struct {
	// All possible effort levels.
	//
	// Any of "low", "medium", "high", "xhigh", "max".
	Effort BetaOutputConfigEffort `json:"effort,omitzero"`
	// A schema to specify Claude's output format in responses. See
	// [structured outputs](https://platform.claude.com/docs/en/build-with-claude/structured-outputs)
	Format BetaJSONOutputFormatParam `json:"format,omitzero"`
	// User-configurable total token budget across contexts.
	TaskBudget BetaTokenTaskBudgetParam `json:"task_budget,omitzero"`
	paramObj
}

func (r BetaOutputConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaOutputConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaOutputConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// All possible effort levels.
type BetaOutputConfigEffort string

const (
	BetaOutputConfigEffortLow    BetaOutputConfigEffort = "low"
	BetaOutputConfigEffortMedium BetaOutputConfigEffort = "medium"
	BetaOutputConfigEffortHigh   BetaOutputConfigEffort = "high"
	BetaOutputConfigEffortXhigh  BetaOutputConfigEffort = "xhigh"
	BetaOutputConfigEffortMax    BetaOutputConfigEffort = "max"
)

type BetaOutputTokensDetails struct {
	// Number of output tokens the model generated as internal reasoning, including the
	// thinking-block delimiter tokens.
	//
	// Reflects the raw reasoning the model produced, not the (possibly shorter)
	// summarized thinking text returned in the response body. Computed by
	// re-tokenizing the raw reasoning text, so it may differ from the model's exact
	// generation count by a small number of tokens. Always ≤ `output_tokens`;
	// `output_tokens - thinking_tokens` approximates the non-reasoning output.
	ThinkingTokens int64 `json:"thinking_tokens" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ThinkingTokens respjson.Field
		ExtraFields    map[string]respjson.Field
		raw            string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaOutputTokensDetails) RawJSON() string { return r.JSON.raw }
func (r *BetaOutputTokensDetails) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaPlainTextSource struct {
	Data      string             `json:"data" api:"required"`
	MediaType constant.TextPlain `json:"media_type" default:"text/plain"`
	Type      constant.Text      `json:"type" default:"text"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Data        respjson.Field
		MediaType   respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaPlainTextSource) RawJSON() string { return r.JSON.raw }
func (r *BetaPlainTextSource) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// ToParam converts this BetaPlainTextSource to a BetaPlainTextSourceParam.
//
// Warning: the fields of the param type will not be present. ToParam should only
// be used at the last possible moment before sending a request. Test for this with
// BetaPlainTextSourceParam.Overrides()
func (r BetaPlainTextSource) ToParam() BetaPlainTextSourceParam {
	return param.Override[BetaPlainTextSourceParam](json.RawMessage(r.RawJSON()))
}

// The properties Data, MediaType, Type are required.
type BetaPlainTextSourceParam struct {
	Data string `json:"data" api:"required"`
	// This field can be elided, and will marshal its zero value as "text/plain".
	MediaType constant.TextPlain `json:"media_type" default:"text/plain"`
	// This field can be elided, and will marshal its zero value as "text".
	Type constant.Text `json:"type" default:"text"`
	paramObj
}

func (r BetaPlainTextSourceParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaPlainTextSourceParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaPlainTextSourceParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// BetaRawContentBlockDeltaUnion contains all possible properties and values from
// [BetaTextDelta], [BetaInputJSONDelta], [BetaCitationsDelta],
// [BetaThinkingDelta], [BetaSignatureDelta], [BetaCompactionContentBlockDelta].
//
// Use the [BetaRawContentBlockDeltaUnion.AsAny] method to switch on the variant.
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
type BetaRawContentBlockDeltaUnion struct {
	// This field is from variant [BetaTextDelta].
	Text string `json:"text"`
	// Any of "text_delta", "input_json_delta", "citations_delta", "thinking_delta",
	// "signature_delta", "compaction_delta".
	Type string `json:"type"`
	// This field is from variant [BetaInputJSONDelta].
	PartialJSON string `json:"partial_json"`
	// This field is from variant [BetaCitationsDelta].
	Citation BetaCitationsDeltaCitationUnion `json:"citation"`
	// This field is from variant [BetaThinkingDelta].
	EstimatedTokens int64 `json:"estimated_tokens"`
	// This field is from variant [BetaThinkingDelta].
	Thinking string `json:"thinking"`
	// This field is from variant [BetaSignatureDelta].
	Signature string `json:"signature"`
	// This field is from variant [BetaCompactionContentBlockDelta].
	Content string `json:"content"`
	// This field is from variant [BetaCompactionContentBlockDelta].
	EncryptedContent string `json:"encrypted_content"`
	JSON             struct {
		Text             respjson.Field
		Type             respjson.Field
		PartialJSON      respjson.Field
		Citation         respjson.Field
		EstimatedTokens  respjson.Field
		Thinking         respjson.Field
		Signature        respjson.Field
		Content          respjson.Field
		EncryptedContent respjson.Field
		raw              string
	} `json:"-"`
}

// anyBetaRawContentBlockDelta is implemented by each variant of
// [BetaRawContentBlockDeltaUnion] to add type safety for the return type of
// [BetaRawContentBlockDeltaUnion.AsAny]
type anyBetaRawContentBlockDelta interface {
	implBetaRawContentBlockDeltaUnion()
}

func (BetaTextDelta) implBetaRawContentBlockDeltaUnion()                   {}
func (BetaInputJSONDelta) implBetaRawContentBlockDeltaUnion()              {}
func (BetaCitationsDelta) implBetaRawContentBlockDeltaUnion()              {}
func (BetaThinkingDelta) implBetaRawContentBlockDeltaUnion()               {}
func (BetaSignatureDelta) implBetaRawContentBlockDeltaUnion()              {}
func (BetaCompactionContentBlockDelta) implBetaRawContentBlockDeltaUnion() {}

// Use the following switch statement to find the correct variant
//
//	switch variant := BetaRawContentBlockDeltaUnion.AsAny().(type) {
//	case anthropic.BetaTextDelta:
//	case anthropic.BetaInputJSONDelta:
//	case anthropic.BetaCitationsDelta:
//	case anthropic.BetaThinkingDelta:
//	case anthropic.BetaSignatureDelta:
//	case anthropic.BetaCompactionContentBlockDelta:
//	default:
//	  fmt.Errorf("no variant present")
//	}
func (u BetaRawContentBlockDeltaUnion) AsAny() anyBetaRawContentBlockDelta {
	switch u.Type {
	case "text_delta":
		return u.AsTextDelta()
	case "input_json_delta":
		return u.AsInputJSONDelta()
	case "citations_delta":
		return u.AsCitationsDelta()
	case "thinking_delta":
		return u.AsThinkingDelta()
	case "signature_delta":
		return u.AsSignatureDelta()
	case "compaction_delta":
		return u.AsCompactionDelta()
	}
	return nil
}

func (u BetaRawContentBlockDeltaUnion) AsTextDelta() (v BetaTextDelta) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaRawContentBlockDeltaUnion) AsInputJSONDelta() (v BetaInputJSONDelta) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaRawContentBlockDeltaUnion) AsCitationsDelta() (v BetaCitationsDelta) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaRawContentBlockDeltaUnion) AsThinkingDelta() (v BetaThinkingDelta) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaRawContentBlockDeltaUnion) AsSignatureDelta() (v BetaSignatureDelta) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaRawContentBlockDeltaUnion) AsCompactionDelta() (v BetaCompactionContentBlockDelta) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u BetaRawContentBlockDeltaUnion) RawJSON() string { return u.JSON.raw }

func (r *BetaRawContentBlockDeltaUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaRawContentBlockDeltaEvent struct {
	Delta BetaRawContentBlockDeltaUnion `json:"delta" api:"required"`
	Index int64                         `json:"index" api:"required"`
	Type  constant.ContentBlockDelta    `json:"type" default:"content_block_delta"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Delta       respjson.Field
		Index       respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaRawContentBlockDeltaEvent) RawJSON() string { return r.JSON.raw }
func (r *BetaRawContentBlockDeltaEvent) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaRawContentBlockStartEvent struct {
	// Response model for a file uploaded to the container.
	ContentBlock BetaRawContentBlockStartEventContentBlockUnion `json:"content_block" api:"required"`
	Index        int64                                          `json:"index" api:"required"`
	Type         constant.ContentBlockStart                     `json:"type" default:"content_block_start"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ContentBlock respjson.Field
		Index        respjson.Field
		Type         respjson.Field
		ExtraFields  map[string]respjson.Field
		raw          string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaRawContentBlockStartEvent) RawJSON() string { return r.JSON.raw }
func (r *BetaRawContentBlockStartEvent) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// BetaRawContentBlockStartEventContentBlockUnion contains all possible properties
// and values from [BetaTextBlock], [BetaThinkingBlock],
// [BetaRedactedThinkingBlock], [BetaToolUseBlock], [BetaServerToolUseBlock],
// [BetaWebSearchToolResultBlock], [BetaWebFetchToolResultBlock],
// [BetaAdvisorToolResultBlock], [BetaCodeExecutionToolResultBlock],
// [BetaBashCodeExecutionToolResultBlock],
// [BetaTextEditorCodeExecutionToolResultBlock], [BetaToolSearchToolResultBlock],
// [BetaMCPToolUseBlock], [BetaMCPToolResultBlock], [BetaContainerUploadBlock],
// [BetaCompactionBlock], [BetaFallbackBlock].
//
// Use the [BetaRawContentBlockStartEventContentBlockUnion.AsAny] method to switch
// on the variant.
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
type BetaRawContentBlockStartEventContentBlockUnion struct {
	// This field is from variant [BetaTextBlock].
	Citations []BetaTextCitationUnion `json:"citations"`
	// This field is from variant [BetaTextBlock].
	Text string `json:"text"`
	// Any of "text", "thinking", "redacted_thinking", "tool_use", "server_tool_use",
	// "web_search_tool_result", "web_fetch_tool_result", "advisor_tool_result",
	// "code_execution_tool_result", "bash_code_execution_tool_result",
	// "text_editor_code_execution_tool_result", "tool_search_tool_result",
	// "mcp_tool_use", "mcp_tool_result", "container_upload", "compaction", "fallback".
	Type string `json:"type"`
	// This field is from variant [BetaThinkingBlock].
	Signature string `json:"signature"`
	// This field is from variant [BetaThinkingBlock].
	Thinking string `json:"thinking"`
	// This field is from variant [BetaRedactedThinkingBlock].
	Data  string `json:"data"`
	ID    string `json:"id"`
	Input any    `json:"input"`
	Name  string `json:"name"`
	// This field is a union of [BetaToolUseBlockCallerUnion],
	// [BetaServerToolUseBlockCallerUnion], [BetaWebSearchToolResultBlockCallerUnion],
	// [BetaWebFetchToolResultBlockCallerUnion]
	Caller BetaRawContentBlockStartEventContentBlockUnionCaller `json:"caller"`
	// This field is from variant [BetaToolUseBlock].
	ToolsetName string `json:"toolset_name"`
	// This field is a union of [BetaWebSearchToolResultBlockContentUnion],
	// [BetaWebFetchToolResultBlockContentUnion],
	// [BetaAdvisorToolResultBlockContentUnion],
	// [BetaCodeExecutionToolResultBlockContentUnion],
	// [BetaBashCodeExecutionToolResultBlockContentUnion],
	// [BetaTextEditorCodeExecutionToolResultBlockContentUnion],
	// [BetaToolSearchToolResultBlockContentUnion],
	// [BetaMCPToolResultBlockContentUnion], [string]
	Content   BetaRawContentBlockStartEventContentBlockUnionContent `json:"content"`
	ToolUseID string                                                `json:"tool_use_id"`
	// This field is from variant [BetaMCPToolUseBlock].
	ServerName string `json:"server_name"`
	// This field is from variant [BetaMCPToolResultBlock].
	IsError bool `json:"is_error"`
	// This field is from variant [BetaContainerUploadBlock].
	FileID string `json:"file_id"`
	// This field is from variant [BetaCompactionBlock].
	EncryptedContent string `json:"encrypted_content"`
	// This field is from variant [BetaFallbackBlock].
	From BetaFallbackInfo `json:"from"`
	// This field is from variant [BetaFallbackBlock].
	To BetaFallbackInfo `json:"to"`
	// This field is from variant [BetaFallbackBlock].
	Trigger BetaFallbackRefusalTrigger `json:"trigger"`
	JSON    struct {
		Citations        respjson.Field
		Text             respjson.Field
		Type             respjson.Field
		Signature        respjson.Field
		Thinking         respjson.Field
		Data             respjson.Field
		ID               respjson.Field
		Input            respjson.Field
		Name             respjson.Field
		Caller           respjson.Field
		ToolsetName      respjson.Field
		Content          respjson.Field
		ToolUseID        respjson.Field
		ServerName       respjson.Field
		IsError          respjson.Field
		FileID           respjson.Field
		EncryptedContent respjson.Field
		From             respjson.Field
		To               respjson.Field
		Trigger          respjson.Field
		raw              string
	} `json:"-"`
}

// anyBetaRawContentBlockStartEventContentBlock is implemented by each variant of
// [BetaRawContentBlockStartEventContentBlockUnion] to add type safety for the
// return type of [BetaRawContentBlockStartEventContentBlockUnion.AsAny]
type anyBetaRawContentBlockStartEventContentBlock interface {
	implBetaRawContentBlockStartEventContentBlockUnion()
}

func (BetaTextBlock) implBetaRawContentBlockStartEventContentBlockUnion()                        {}
func (BetaThinkingBlock) implBetaRawContentBlockStartEventContentBlockUnion()                    {}
func (BetaRedactedThinkingBlock) implBetaRawContentBlockStartEventContentBlockUnion()            {}
func (BetaToolUseBlock) implBetaRawContentBlockStartEventContentBlockUnion()                     {}
func (BetaServerToolUseBlock) implBetaRawContentBlockStartEventContentBlockUnion()               {}
func (BetaWebSearchToolResultBlock) implBetaRawContentBlockStartEventContentBlockUnion()         {}
func (BetaWebFetchToolResultBlock) implBetaRawContentBlockStartEventContentBlockUnion()          {}
func (BetaAdvisorToolResultBlock) implBetaRawContentBlockStartEventContentBlockUnion()           {}
func (BetaCodeExecutionToolResultBlock) implBetaRawContentBlockStartEventContentBlockUnion()     {}
func (BetaBashCodeExecutionToolResultBlock) implBetaRawContentBlockStartEventContentBlockUnion() {}
func (BetaTextEditorCodeExecutionToolResultBlock) implBetaRawContentBlockStartEventContentBlockUnion() {
}
func (BetaToolSearchToolResultBlock) implBetaRawContentBlockStartEventContentBlockUnion() {}
func (BetaMCPToolUseBlock) implBetaRawContentBlockStartEventContentBlockUnion()           {}
func (BetaMCPToolResultBlock) implBetaRawContentBlockStartEventContentBlockUnion()        {}
func (BetaContainerUploadBlock) implBetaRawContentBlockStartEventContentBlockUnion()      {}
func (BetaCompactionBlock) implBetaRawContentBlockStartEventContentBlockUnion()           {}
func (BetaFallbackBlock) implBetaRawContentBlockStartEventContentBlockUnion()             {}

// Use the following switch statement to find the correct variant
//
//	switch variant := BetaRawContentBlockStartEventContentBlockUnion.AsAny().(type) {
//	case anthropic.BetaTextBlock:
//	case anthropic.BetaThinkingBlock:
//	case anthropic.BetaRedactedThinkingBlock:
//	case anthropic.BetaToolUseBlock:
//	case anthropic.BetaServerToolUseBlock:
//	case anthropic.BetaWebSearchToolResultBlock:
//	case anthropic.BetaWebFetchToolResultBlock:
//	case anthropic.BetaAdvisorToolResultBlock:
//	case anthropic.BetaCodeExecutionToolResultBlock:
//	case anthropic.BetaBashCodeExecutionToolResultBlock:
//	case anthropic.BetaTextEditorCodeExecutionToolResultBlock:
//	case anthropic.BetaToolSearchToolResultBlock:
//	case anthropic.BetaMCPToolUseBlock:
//	case anthropic.BetaMCPToolResultBlock:
//	case anthropic.BetaContainerUploadBlock:
//	case anthropic.BetaCompactionBlock:
//	case anthropic.BetaFallbackBlock:
//	default:
//	  fmt.Errorf("no variant present")
//	}
func (u BetaRawContentBlockStartEventContentBlockUnion) AsAny() anyBetaRawContentBlockStartEventContentBlock {
	switch u.Type {
	case "text":
		return u.AsText()
	case "thinking":
		return u.AsThinking()
	case "redacted_thinking":
		return u.AsRedactedThinking()
	case "tool_use":
		return u.AsToolUse()
	case "server_tool_use":
		return u.AsServerToolUse()
	case "web_search_tool_result":
		return u.AsWebSearchToolResult()
	case "web_fetch_tool_result":
		return u.AsWebFetchToolResult()
	case "advisor_tool_result":
		return u.AsAdvisorToolResult()
	case "code_execution_tool_result":
		return u.AsCodeExecutionToolResult()
	case "bash_code_execution_tool_result":
		return u.AsBashCodeExecutionToolResult()
	case "text_editor_code_execution_tool_result":
		return u.AsTextEditorCodeExecutionToolResult()
	case "tool_search_tool_result":
		return u.AsToolSearchToolResult()
	case "mcp_tool_use":
		return u.AsMCPToolUse()
	case "mcp_tool_result":
		return u.AsMCPToolResult()
	case "container_upload":
		return u.AsContainerUpload()
	case "compaction":
		return u.AsCompaction()
	case "fallback":
		return u.AsFallback()
	}
	return nil
}

func (u BetaRawContentBlockStartEventContentBlockUnion) AsText() (v BetaTextBlock) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaRawContentBlockStartEventContentBlockUnion) AsThinking() (v BetaThinkingBlock) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaRawContentBlockStartEventContentBlockUnion) AsRedactedThinking() (v BetaRedactedThinkingBlock) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaRawContentBlockStartEventContentBlockUnion) AsToolUse() (v BetaToolUseBlock) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaRawContentBlockStartEventContentBlockUnion) AsServerToolUse() (v BetaServerToolUseBlock) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaRawContentBlockStartEventContentBlockUnion) AsWebSearchToolResult() (v BetaWebSearchToolResultBlock) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaRawContentBlockStartEventContentBlockUnion) AsWebFetchToolResult() (v BetaWebFetchToolResultBlock) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaRawContentBlockStartEventContentBlockUnion) AsAdvisorToolResult() (v BetaAdvisorToolResultBlock) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaRawContentBlockStartEventContentBlockUnion) AsCodeExecutionToolResult() (v BetaCodeExecutionToolResultBlock) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaRawContentBlockStartEventContentBlockUnion) AsBashCodeExecutionToolResult() (v BetaBashCodeExecutionToolResultBlock) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaRawContentBlockStartEventContentBlockUnion) AsTextEditorCodeExecutionToolResult() (v BetaTextEditorCodeExecutionToolResultBlock) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaRawContentBlockStartEventContentBlockUnion) AsToolSearchToolResult() (v BetaToolSearchToolResultBlock) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaRawContentBlockStartEventContentBlockUnion) AsMCPToolUse() (v BetaMCPToolUseBlock) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaRawContentBlockStartEventContentBlockUnion) AsMCPToolResult() (v BetaMCPToolResultBlock) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaRawContentBlockStartEventContentBlockUnion) AsContainerUpload() (v BetaContainerUploadBlock) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaRawContentBlockStartEventContentBlockUnion) AsCompaction() (v BetaCompactionBlock) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaRawContentBlockStartEventContentBlockUnion) AsFallback() (v BetaFallbackBlock) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u BetaRawContentBlockStartEventContentBlockUnion) RawJSON() string { return u.JSON.raw }

func (r *BetaRawContentBlockStartEventContentBlockUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// BetaRawContentBlockStartEventContentBlockUnionCaller is an implicit subunion of
// [BetaRawContentBlockStartEventContentBlockUnion].
// BetaRawContentBlockStartEventContentBlockUnionCaller provides convenient access
// to the sub-properties of the union.
//
// For type safety it is recommended to directly use a variant of the
// [BetaRawContentBlockStartEventContentBlockUnion].
type BetaRawContentBlockStartEventContentBlockUnionCaller struct {
	Type   string `json:"type"`
	ToolID string `json:"tool_id"`
	JSON   struct {
		Type   respjson.Field
		ToolID respjson.Field
		raw    string
	} `json:"-"`
}

func (r *BetaRawContentBlockStartEventContentBlockUnionCaller) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// BetaRawContentBlockStartEventContentBlockUnionContent is an implicit subunion of
// [BetaRawContentBlockStartEventContentBlockUnion].
// BetaRawContentBlockStartEventContentBlockUnionContent provides convenient access
// to the sub-properties of the union.
//
// For type safety it is recommended to directly use a variant of the
// [BetaRawContentBlockStartEventContentBlockUnion].
//
// If the underlying value is not a json object, one of the following properties
// will be valid: OfBetaWebSearchResultBlockArray OfString
// OfBetaMCPToolResultBlockContent]
type BetaRawContentBlockStartEventContentBlockUnionContent struct {
	// This field will be present if the value is a [[]BetaWebSearchResultBlock]
	// instead of an object.
	OfBetaWebSearchResultBlockArray []BetaWebSearchResultBlock `json:",inline"`
	// This field will be present if the value is a [string] instead of an object.
	OfString string `json:",inline"`
	// This field will be present if the value is a [[]BetaTextBlock] instead of an
	// object.
	OfBetaMCPToolResultBlockContent []BetaTextBlock `json:",inline"`
	ErrorCode                       string          `json:"error_code"`
	Type                            string          `json:"type"`
	// This field is a union of [BetaDocumentBlock], [[]BetaCodeExecutionOutputBlock],
	// [[]BetaCodeExecutionOutputBlock], [[]BetaBashCodeExecutionOutputBlock], [string]
	Content BetaRawContentBlockStartEventContentBlockUnionContentContent `json:"content"`
	// This field is from variant [BetaWebFetchToolResultBlockContentUnion].
	RetrievedAt string `json:"retrieved_at"`
	// This field is from variant [BetaWebFetchToolResultBlockContentUnion].
	URL        string `json:"url"`
	StopReason string `json:"stop_reason"`
	// This field is from variant [BetaAdvisorToolResultBlockContentUnion].
	Text string `json:"text"`
	// This field is from variant [BetaAdvisorToolResultBlockContentUnion].
	EncryptedContent string `json:"encrypted_content"`
	ReturnCode       int64  `json:"return_code"`
	Stderr           string `json:"stderr"`
	Stdout           string `json:"stdout"`
	// This field is from variant [BetaCodeExecutionToolResultBlockContentUnion].
	EncryptedStdout string `json:"encrypted_stdout"`
	ErrorMessage    string `json:"error_message"`
	// This field is from variant
	// [BetaTextEditorCodeExecutionToolResultBlockContentUnion].
	FileType BetaTextEditorCodeExecutionViewResultBlockFileType `json:"file_type"`
	// This field is from variant
	// [BetaTextEditorCodeExecutionToolResultBlockContentUnion].
	NumLines int64 `json:"num_lines"`
	// This field is from variant
	// [BetaTextEditorCodeExecutionToolResultBlockContentUnion].
	StartLine int64 `json:"start_line"`
	// This field is from variant
	// [BetaTextEditorCodeExecutionToolResultBlockContentUnion].
	TotalLines int64 `json:"total_lines"`
	// This field is from variant
	// [BetaTextEditorCodeExecutionToolResultBlockContentUnion].
	IsFileUpdate bool `json:"is_file_update"`
	// This field is from variant
	// [BetaTextEditorCodeExecutionToolResultBlockContentUnion].
	Lines []string `json:"lines"`
	// This field is from variant
	// [BetaTextEditorCodeExecutionToolResultBlockContentUnion].
	NewLines int64 `json:"new_lines"`
	// This field is from variant
	// [BetaTextEditorCodeExecutionToolResultBlockContentUnion].
	NewStart int64 `json:"new_start"`
	// This field is from variant
	// [BetaTextEditorCodeExecutionToolResultBlockContentUnion].
	OldLines int64 `json:"old_lines"`
	// This field is from variant
	// [BetaTextEditorCodeExecutionToolResultBlockContentUnion].
	OldStart int64 `json:"old_start"`
	// This field is from variant [BetaToolSearchToolResultBlockContentUnion].
	ToolReferences []BetaToolReferenceBlock `json:"tool_references"`
	JSON           struct {
		OfBetaWebSearchResultBlockArray respjson.Field
		OfString                        respjson.Field
		OfBetaMCPToolResultBlockContent respjson.Field
		ErrorCode                       respjson.Field
		Type                            respjson.Field
		Content                         respjson.Field
		RetrievedAt                     respjson.Field
		URL                             respjson.Field
		StopReason                      respjson.Field
		Text                            respjson.Field
		EncryptedContent                respjson.Field
		ReturnCode                      respjson.Field
		Stderr                          respjson.Field
		Stdout                          respjson.Field
		EncryptedStdout                 respjson.Field
		ErrorMessage                    respjson.Field
		FileType                        respjson.Field
		NumLines                        respjson.Field
		StartLine                       respjson.Field
		TotalLines                      respjson.Field
		IsFileUpdate                    respjson.Field
		Lines                           respjson.Field
		NewLines                        respjson.Field
		NewStart                        respjson.Field
		OldLines                        respjson.Field
		OldStart                        respjson.Field
		ToolReferences                  respjson.Field
		raw                             string
	} `json:"-"`
}

func (r *BetaRawContentBlockStartEventContentBlockUnionContent) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// BetaRawContentBlockStartEventContentBlockUnionContentContent is an implicit
// subunion of [BetaRawContentBlockStartEventContentBlockUnion].
// BetaRawContentBlockStartEventContentBlockUnionContentContent provides convenient
// access to the sub-properties of the union.
//
// For type safety it is recommended to directly use a variant of the
// [BetaRawContentBlockStartEventContentBlockUnion].
//
// If the underlying value is not a json object, one of the following properties
// will be valid: OfContent OfString]
type BetaRawContentBlockStartEventContentBlockUnionContentContent struct {
	// This field will be present if the value is a [[]BetaCodeExecutionOutputBlock]
	// instead of an object.
	OfContent []BetaCodeExecutionOutputBlock `json:",inline"`
	// This field will be present if the value is a [string] instead of an object.
	OfString string `json:",inline"`
	// This field is from variant [BetaDocumentBlock].
	Citations BetaCitationConfig `json:"citations"`
	// This field is from variant [BetaDocumentBlock].
	Source BetaDocumentBlockSourceUnion `json:"source"`
	// This field is from variant [BetaDocumentBlock].
	Title string `json:"title"`
	// This field is from variant [BetaDocumentBlock].
	Type constant.Document `json:"type"`
	JSON struct {
		OfContent respjson.Field
		OfString  respjson.Field
		Citations respjson.Field
		Source    respjson.Field
		Title     respjson.Field
		Type      respjson.Field
		raw       string
	} `json:"-"`
}

func (r *BetaRawContentBlockStartEventContentBlockUnionContentContent) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaRawContentBlockStopEvent struct {
	Index int64                     `json:"index" api:"required"`
	Type  constant.ContentBlockStop `json:"type" default:"content_block_stop"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Index       respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaRawContentBlockStopEvent) RawJSON() string { return r.JSON.raw }
func (r *BetaRawContentBlockStopEvent) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaRawMessageDeltaEvent struct {
	// Information about context management strategies applied during the request
	ContextManagement BetaContextManagementResponse `json:"context_management" api:"required"`
	Delta             BetaRawMessageDeltaEventDelta `json:"delta" api:"required"`
	Type              constant.MessageDelta         `json:"type" default:"message_delta"`
	// Billing and rate-limit usage.
	//
	// Anthropic's API bills and rate-limits by token counts, as tokens represent the
	// underlying cost to our systems.
	//
	// Under the hood, the API transforms requests into a format suitable for the
	// model. The model's output then goes through a parsing stage before becoming an
	// API response. As a result, the token counts in `usage` will not match one-to-one
	// with the exact visible content of an API request or response.
	//
	// For example, `output_tokens` will be non-zero, even for an empty string response
	// from Claude.
	//
	// Total input tokens in a request is the summation of `input_tokens`,
	// `cache_creation_input_tokens`, and `cache_read_input_tokens`.
	Usage BetaMessageDeltaUsage `json:"usage" api:"required"`
	// Changes the API made to the request's input before showing it to the model: one
	// entry per change, in request order. Today the only entry type is
	// `thinking_dropped` — a `thinking`, `redacted_thinking` or `connector_text` block
	// from the request's `messages` that was removed from the prompt instead of being
	// shown to the model because it failed a binding check. More entry types may be
	// added over time; ignore types you do not recognize.
	//
	// Requires `anthropic-beta: thinking-binding-controls-2026-08-01`. Present on
	// every such response from a model that supports extended thinking, as `[]` when
	// nothing was changed; without the beta, blocks are removed all the same but
	// nothing is reported. Removed blocks contribute nothing to `usage.input_tokens`.
	// When streaming, the array is final in `message_start`; the final `message_delta`
	// event carries it only when a server-side model fallback happened mid-stream, in
	// which case it holds the serving model's entries and replaces the one in
	// `message_start`.
	InputTransformations []BetaThinkingDroppedInputTransformation `json:"input_transformations" api:"nullable"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ContextManagement    respjson.Field
		Delta                respjson.Field
		Type                 respjson.Field
		Usage                respjson.Field
		InputTransformations respjson.Field
		ExtraFields          map[string]respjson.Field
		raw                  string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaRawMessageDeltaEvent) RawJSON() string { return r.JSON.raw }
func (r *BetaRawMessageDeltaEvent) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaRawMessageDeltaEventDelta struct {
	// Information about the container used in the request (for the code execution
	// tool)
	Container BetaContainer `json:"container" api:"required"`
	// Structured information about a refusal.
	StopDetails BetaRefusalStopDetails `json:"stop_details" api:"required"`
	// Any of "end_turn", "max_tokens", "stop_sequence", "tool_use", "pause_turn",
	// "compaction", "refusal", "model_context_window_exceeded".
	StopReason   BetaStopReason `json:"stop_reason" api:"required"`
	StopSequence string         `json:"stop_sequence" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Container    respjson.Field
		StopDetails  respjson.Field
		StopReason   respjson.Field
		StopSequence respjson.Field
		ExtraFields  map[string]respjson.Field
		raw          string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaRawMessageDeltaEventDelta) RawJSON() string { return r.JSON.raw }
func (r *BetaRawMessageDeltaEventDelta) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaRawMessageStartEvent struct {
	Message BetaMessage           `json:"message" api:"required"`
	Type    constant.MessageStart `json:"type" default:"message_start"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Message     respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaRawMessageStartEvent) RawJSON() string { return r.JSON.raw }
func (r *BetaRawMessageStartEvent) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaRawMessageStopEvent struct {
	Type constant.MessageStop `json:"type" default:"message_stop"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaRawMessageStopEvent) RawJSON() string { return r.JSON.raw }
func (r *BetaRawMessageStopEvent) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// BetaRawMessageStreamEventUnion contains all possible properties and values from
// [BetaRawMessageStartEvent], [BetaRawMessageDeltaEvent],
// [BetaRawMessageStopEvent], [BetaRawContentBlockStartEvent],
// [BetaRawContentBlockDeltaEvent], [BetaRawContentBlockStopEvent].
//
// Use the [BetaRawMessageStreamEventUnion.AsAny] method to switch on the variant.
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
type BetaRawMessageStreamEventUnion struct {
	// This field is from variant [BetaRawMessageStartEvent].
	Message BetaMessage `json:"message"`
	// Any of "message_start", "message_delta", "message_stop", "content_block_start",
	// "content_block_delta", "content_block_stop".
	Type string `json:"type"`
	// This field is from variant [BetaRawMessageDeltaEvent].
	ContextManagement BetaContextManagementResponse `json:"context_management"`
	// This field is a union of [BetaRawMessageDeltaEventDelta],
	// [BetaRawContentBlockDeltaUnion]
	Delta BetaRawMessageStreamEventUnionDelta `json:"delta"`
	// This field is from variant [BetaRawMessageDeltaEvent].
	Usage BetaMessageDeltaUsage `json:"usage"`
	// This field is from variant [BetaRawMessageDeltaEvent].
	InputTransformations []BetaThinkingDroppedInputTransformation `json:"input_transformations"`
	// This field is from variant [BetaRawContentBlockStartEvent].
	ContentBlock BetaRawContentBlockStartEventContentBlockUnion `json:"content_block"`
	Index        int64                                          `json:"index"`
	JSON         struct {
		Message              respjson.Field
		Type                 respjson.Field
		ContextManagement    respjson.Field
		Delta                respjson.Field
		Usage                respjson.Field
		InputTransformations respjson.Field
		ContentBlock         respjson.Field
		Index                respjson.Field
		raw                  string
	} `json:"-"`
}

// anyBetaRawMessageStreamEvent is implemented by each variant of
// [BetaRawMessageStreamEventUnion] to add type safety for the return type of
// [BetaRawMessageStreamEventUnion.AsAny]
type anyBetaRawMessageStreamEvent interface {
	implBetaRawMessageStreamEventUnion()
}

func (BetaRawMessageStartEvent) implBetaRawMessageStreamEventUnion()      {}
func (BetaRawMessageDeltaEvent) implBetaRawMessageStreamEventUnion()      {}
func (BetaRawMessageStopEvent) implBetaRawMessageStreamEventUnion()       {}
func (BetaRawContentBlockStartEvent) implBetaRawMessageStreamEventUnion() {}
func (BetaRawContentBlockDeltaEvent) implBetaRawMessageStreamEventUnion() {}
func (BetaRawContentBlockStopEvent) implBetaRawMessageStreamEventUnion()  {}

// Use the following switch statement to find the correct variant
//
//	switch variant := BetaRawMessageStreamEventUnion.AsAny().(type) {
//	case anthropic.BetaRawMessageStartEvent:
//	case anthropic.BetaRawMessageDeltaEvent:
//	case anthropic.BetaRawMessageStopEvent:
//	case anthropic.BetaRawContentBlockStartEvent:
//	case anthropic.BetaRawContentBlockDeltaEvent:
//	case anthropic.BetaRawContentBlockStopEvent:
//	default:
//	  fmt.Errorf("no variant present")
//	}
func (u BetaRawMessageStreamEventUnion) AsAny() anyBetaRawMessageStreamEvent {
	switch u.Type {
	case "message_start":
		return u.AsMessageStart()
	case "message_delta":
		return u.AsMessageDelta()
	case "message_stop":
		return u.AsMessageStop()
	case "content_block_start":
		return u.AsContentBlockStart()
	case "content_block_delta":
		return u.AsContentBlockDelta()
	case "content_block_stop":
		return u.AsContentBlockStop()
	}
	return nil
}

func (u BetaRawMessageStreamEventUnion) AsMessageStart() (v BetaRawMessageStartEvent) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaRawMessageStreamEventUnion) AsMessageDelta() (v BetaRawMessageDeltaEvent) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaRawMessageStreamEventUnion) AsMessageStop() (v BetaRawMessageStopEvent) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaRawMessageStreamEventUnion) AsContentBlockStart() (v BetaRawContentBlockStartEvent) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaRawMessageStreamEventUnion) AsContentBlockDelta() (v BetaRawContentBlockDeltaEvent) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaRawMessageStreamEventUnion) AsContentBlockStop() (v BetaRawContentBlockStopEvent) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u BetaRawMessageStreamEventUnion) RawJSON() string { return u.JSON.raw }

func (r *BetaRawMessageStreamEventUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// BetaRawMessageStreamEventUnionDelta is an implicit subunion of
// [BetaRawMessageStreamEventUnion]. BetaRawMessageStreamEventUnionDelta provides
// convenient access to the sub-properties of the union.
//
// For type safety it is recommended to directly use a variant of the
// [BetaRawMessageStreamEventUnion].
type BetaRawMessageStreamEventUnionDelta struct {
	// This field is from variant [BetaRawMessageDeltaEventDelta].
	Container BetaContainer `json:"container"`
	// This field is from variant [BetaRawMessageDeltaEventDelta].
	StopDetails BetaRefusalStopDetails `json:"stop_details"`
	// This field is from variant [BetaRawMessageDeltaEventDelta].
	StopReason BetaStopReason `json:"stop_reason"`
	// This field is from variant [BetaRawMessageDeltaEventDelta].
	StopSequence string `json:"stop_sequence"`
	// This field is from variant [BetaRawContentBlockDeltaUnion].
	Text string `json:"text"`
	Type string `json:"type"`
	// This field is from variant [BetaRawContentBlockDeltaUnion].
	PartialJSON string `json:"partial_json"`
	// This field is from variant [BetaRawContentBlockDeltaUnion].
	Citation BetaCitationsDeltaCitationUnion `json:"citation"`
	// This field is from variant [BetaRawContentBlockDeltaUnion].
	EstimatedTokens int64 `json:"estimated_tokens"`
	// This field is from variant [BetaRawContentBlockDeltaUnion].
	Thinking string `json:"thinking"`
	// This field is from variant [BetaRawContentBlockDeltaUnion].
	Signature string `json:"signature"`
	// This field is from variant [BetaRawContentBlockDeltaUnion].
	Content string `json:"content"`
	// This field is from variant [BetaRawContentBlockDeltaUnion].
	EncryptedContent string `json:"encrypted_content"`
	JSON             struct {
		Container        respjson.Field
		StopDetails      respjson.Field
		StopReason       respjson.Field
		StopSequence     respjson.Field
		Text             respjson.Field
		Type             respjson.Field
		PartialJSON      respjson.Field
		Citation         respjson.Field
		EstimatedTokens  respjson.Field
		Thinking         respjson.Field
		Signature        respjson.Field
		Content          respjson.Field
		EncryptedContent respjson.Field
		raw              string
	} `json:"-"`
}

func (r *BetaRawMessageStreamEventUnionDelta) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaRedactedThinkingBlock struct {
	// The contents of this redacted thinking block, returned when portions of the
	// model's thinking were safety-redacted. This field is opaque and encrypted, with
	// no readable content.
	//
	// Pass `redacted_thinking` blocks back to the API unchanged when continuing a
	// multi-turn conversation.
	//
	// See
	// [extended thinking](https://platform.claude.com/docs/en/build-with-claude/extended-thinking#redacted-thinking-blocks)
	// for details.
	Data string                    `json:"data" api:"required"`
	Type constant.RedactedThinking `json:"type" default:"redacted_thinking"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Data        respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaRedactedThinkingBlock) RawJSON() string { return r.JSON.raw }
func (r *BetaRedactedThinkingBlock) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties Data, Type are required.
type BetaRedactedThinkingBlockParam struct {
	// The `data` value of this redacted thinking block, exactly as returned by the API
	// in a previous response. Opaque and encrypted; pass it back unchanged.
	Data string `json:"data" api:"required"`
	// This field can be elided, and will marshal its zero value as
	// "redacted_thinking".
	Type constant.RedactedThinking `json:"type" default:"redacted_thinking"`
	paramObj
}

func (r BetaRedactedThinkingBlockParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaRedactedThinkingBlockParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaRedactedThinkingBlockParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Structured information about a refusal.
type BetaRefusalStopDetails struct {
	// The policy category that triggered a refusal.
	//
	// Any of "cyber", "bio", "frontier_llm", "reasoning_extraction", "general_harms".
	Category BetaRefusalStopDetailsCategory `json:"category" api:"required"`
	// Human-readable explanation of the refusal.
	//
	// This text is not guaranteed to be stable. `null` when no explanation is
	// available for the category.
	Explanation string `json:"explanation" api:"required"`
	// Opaque code that refunds the cache-miss cost when retrying this refused request
	// on the fallback model. Pass it as `fallback_credit_token` on the retry request.
	// Expires 5 minutes after the refusal.
	//
	// The retry is sent either with the same request body (`system`, `messages`,
	// `tools`, and other render-shaping fields), or with the same body plus one
	// appended `assistant` message whose content is the partial text (with any
	// trailing whitespace stripped from the final text block) and paired server-tool
	// blocks from this refusal — which also authorizes that appended turn as an
	// assistant-prefill continuation on models that otherwise disallow prefill. A
	// token minted mid-server-tool-loop whose partial content was continuable may only
	// be redeemed the second way — if a same-body retry is rejected with a 400 saying
	// the token must be redeemed by continuing the partial response, retry the second
	// way instead. Either way: same workspace, same platform; a mismatch is a 400.
	// Resending a token for an already-warm prefix is permitted but yields no
	// additional credit.
	//
	// `null` when the refused model isn't eligible for a fallback credit.
	FallbackCreditToken string `json:"fallback_credit_token" api:"required"`
	// Whether the accompanying `fallback_credit_token` may be redeemed with the
	// appended-assistant retry form. Only set when `fallback_credit_token` is present.
	//
	// `true`: retry by resending the same request body plus one appended `assistant`
	// message whose content is this response's `content` with any trailing whitespace
	// stripped from the final text block and unpaired `tool_use` blocks omitted (the
	// same appended-turn shape described on `fallback_credit_token`), with the token
	// attached. `false`: retry by resending the original request body unchanged, with
	// the token attached — the appended-assistant form is not available for this
	// refusal (no continuable partial content, or the request uses `output_format` or
	// a `tool_choice` that forces tool use). One exception: when the request used
	// `output_format` or a forced `tool_choice` and the refusal arrived after server
	// tools (including MCP connector tools) had already executed, the token may not be
	// redeemable by either retry form; if the exact-body retry is then rejected with a
	// 400 saying the token must be redeemed by continuing the partial response,
	// discard the token and retry without it.
	//
	// Advisory: if an appended-assistant retry is rejected with a 400 despite `true`,
	// fall back to resending the original request body with the token.
	FallbackHasPrefillClaim bool `json:"fallback_has_prefill_claim" api:"required"`
	// The server's suggested retry target for this refusal. Populated when a fallback
	// attempt could not be made (the fallback model's rate limit was exhausted, or it
	// was overloaded); names the fallback model the caller can retry directly. Null
	// otherwise.
	RecommendedModel string           `json:"recommended_model" api:"required"`
	Type             constant.Refusal `json:"type" default:"refusal"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Category                respjson.Field
		Explanation             respjson.Field
		FallbackCreditToken     respjson.Field
		FallbackHasPrefillClaim respjson.Field
		RecommendedModel        respjson.Field
		Type                    respjson.Field
		ExtraFields             map[string]respjson.Field
		raw                     string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaRefusalStopDetails) RawJSON() string { return r.JSON.raw }
func (r *BetaRefusalStopDetails) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The policy category that triggered a refusal.
type BetaRefusalStopDetailsCategory string

const (
	BetaRefusalStopDetailsCategoryCyber               BetaRefusalStopDetailsCategory = "cyber"
	BetaRefusalStopDetailsCategoryBio                 BetaRefusalStopDetailsCategory = "bio"
	BetaRefusalStopDetailsCategoryFrontierLLM         BetaRefusalStopDetailsCategory = "frontier_llm"
	BetaRefusalStopDetailsCategoryReasoningExtraction BetaRefusalStopDetailsCategory = "reasoning_extraction"
	BetaRefusalStopDetailsCategoryGeneralHarms        BetaRefusalStopDetailsCategory = "general_harms"
)

// The properties Source, Type are required.
type BetaRequestDocumentBlockParam struct {
	Source  BetaRequestDocumentBlockSourceUnionParam `json:"source,omitzero" api:"required"`
	Context param.Opt[string]                        `json:"context,omitzero"`
	Title   param.Opt[string]                        `json:"title,omitzero"`
	// Create a cache control breakpoint at this content block.
	CacheControl BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	Citations    BetaCitationsConfigParam       `json:"citations,omitzero"`
	// This field can be elided, and will marshal its zero value as "document".
	Type constant.Document `json:"type" default:"document"`
	paramObj
}

func (r BetaRequestDocumentBlockParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaRequestDocumentBlockParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaRequestDocumentBlockParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Only one field can be non-zero.
//
// Use [param.IsOmitted] to confirm if a field is set.
type BetaRequestDocumentBlockSourceUnionParam struct {
	OfBase64  *BetaBase64PDFSourceParam    `json:",omitzero,inline"`
	OfText    *BetaPlainTextSourceParam    `json:",omitzero,inline"`
	OfContent *BetaContentBlockSourceParam `json:",omitzero,inline"`
	OfURL     *BetaURLPDFSourceParam       `json:",omitzero,inline"`
	OfFile    *BetaFileDocumentSourceParam `json:",omitzero,inline"`
	paramUnion
}

func (u BetaRequestDocumentBlockSourceUnionParam) MarshalJSON() ([]byte, error) {
	return param.MarshalUnion(u, u.OfBase64,
		u.OfText,
		u.OfContent,
		u.OfURL,
		u.OfFile)
}
func (u *BetaRequestDocumentBlockSourceUnionParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, u)
}

func (u *BetaRequestDocumentBlockSourceUnionParam) asAny() any {
	if !param.IsOmitted(u.OfBase64) {
		return u.OfBase64
	} else if !param.IsOmitted(u.OfText) {
		return u.OfText
	} else if !param.IsOmitted(u.OfContent) {
		return u.OfContent
	} else if !param.IsOmitted(u.OfURL) {
		return u.OfURL
	} else if !param.IsOmitted(u.OfFile) {
		return u.OfFile
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaRequestDocumentBlockSourceUnionParam) GetContent() *BetaContentBlockSourceContentUnionParam {
	if vt := u.OfContent; vt != nil {
		return &vt.Content
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaRequestDocumentBlockSourceUnionParam) GetURL() *string {
	if vt := u.OfURL; vt != nil {
		return &vt.URL
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaRequestDocumentBlockSourceUnionParam) GetFileID() *string {
	if vt := u.OfFile; vt != nil {
		return &vt.FileID
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaRequestDocumentBlockSourceUnionParam) GetData() *string {
	if vt := u.OfBase64; vt != nil {
		return (*string)(&vt.Data)
	} else if vt := u.OfText; vt != nil {
		return (*string)(&vt.Data)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaRequestDocumentBlockSourceUnionParam) GetMediaType() *string {
	if vt := u.OfBase64; vt != nil {
		return (*string)(&vt.MediaType)
	} else if vt := u.OfText; vt != nil {
		return (*string)(&vt.MediaType)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaRequestDocumentBlockSourceUnionParam) GetType() *string {
	if vt := u.OfBase64; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfText; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfContent; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfURL; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfFile; vt != nil {
		return (*string)(&vt.Type)
	}
	return nil
}

func init() {
	apijson.RegisterUnion[BetaRequestDocumentBlockSourceUnionParam](
		"type",
		apijson.Discriminator[BetaBase64PDFSourceParam]("base64"),
		apijson.Discriminator[BetaPlainTextSourceParam]("text"),
		apijson.Discriminator[BetaContentBlockSourceParam]("content"),
		apijson.Discriminator[BetaURLPDFSourceParam]("url"),
		apijson.Discriminator[BetaFileDocumentSourceParam]("file"),
	)
}

type BetaRequestMCPServerToolConfigurationParam struct {
	Enabled      param.Opt[bool] `json:"enabled,omitzero"`
	AllowedTools []string        `json:"allowed_tools,omitzero"`
	paramObj
}

func (r BetaRequestMCPServerToolConfigurationParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaRequestMCPServerToolConfigurationParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaRequestMCPServerToolConfigurationParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties Name, Type, URL are required.
type BetaRequestMCPServerURLDefinitionParam struct {
	Name               string                                     `json:"name" api:"required"`
	URL                string                                     `json:"url" api:"required"`
	AuthorizationToken param.Opt[string]                          `json:"authorization_token,omitzero"`
	ToolConfiguration  BetaRequestMCPServerToolConfigurationParam `json:"tool_configuration,omitzero"`
	// This field can be elided, and will marshal its zero value as "url".
	Type constant.URL `json:"type" default:"url"`
	paramObj
}

func (r BetaRequestMCPServerURLDefinitionParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaRequestMCPServerURLDefinitionParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaRequestMCPServerURLDefinitionParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties ToolUseID, Type are required.
type BetaRequestMCPToolResultBlockParam struct {
	ToolUseID string          `json:"tool_use_id" api:"required"`
	IsError   param.Opt[bool] `json:"is_error,omitzero"`
	// Create a cache control breakpoint at this content block.
	CacheControl BetaCacheControlEphemeralParam                 `json:"cache_control,omitzero"`
	Content      BetaRequestMCPToolResultBlockParamContentUnion `json:"content,omitzero"`
	// This field can be elided, and will marshal its zero value as "mcp_tool_result".
	Type constant.MCPToolResult `json:"type" default:"mcp_tool_result"`
	paramObj
}

func (r BetaRequestMCPToolResultBlockParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaRequestMCPToolResultBlockParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaRequestMCPToolResultBlockParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Only one field can be non-zero.
//
// Use [param.IsOmitted] to confirm if a field is set.
type BetaRequestMCPToolResultBlockParamContentUnion struct {
	OfString                        param.Opt[string]    `json:",omitzero,inline"`
	OfBetaMCPToolResultBlockContent []BetaTextBlockParam `json:",omitzero,inline"`
	paramUnion
}

func (u BetaRequestMCPToolResultBlockParamContentUnion) MarshalJSON() ([]byte, error) {
	return param.MarshalUnion(u, u.OfString, u.OfBetaMCPToolResultBlockContent)
}
func (u *BetaRequestMCPToolResultBlockParamContentUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, u)
}

func (u *BetaRequestMCPToolResultBlockParamContentUnion) asAny() any {
	if !param.IsOmitted(u.OfString) {
		return &u.OfString.Value
	} else if !param.IsOmitted(u.OfBetaMCPToolResultBlockContent) {
		return &u.OfBetaMCPToolResultBlockContent
	}
	return nil
}

// Mid-conversation directive to surface a declared tool.
//
// `tool` references a tool (or MCP toolset) by name from the request's `tools`; it
// is offered to the model from this point in the conversation onward.
//
// The properties Tool, Type are required.
type BetaRequestToolAdditionBlockParam struct {
	// Reference to a single tool the caller declared directly in `tools[]`. Does not
	// accept the composed `{server}_{name}` form the server assigns to MCP-resolved
	// tools — use `mcp_tool_reference` or `mcp_toolset_reference` for those.
	Tool BetaRequestToolAdditionBlockToolUnionParam `json:"tool,omitzero" api:"required"`
	// Create a cache control breakpoint at this content block.
	CacheControl BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	// This field can be elided, and will marshal its zero value as "tool_addition".
	Type constant.ToolAddition `json:"type" default:"tool_addition"`
	paramObj
}

func (r BetaRequestToolAdditionBlockParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaRequestToolAdditionBlockParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaRequestToolAdditionBlockParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Only one field can be non-zero.
//
// Use [param.IsOmitted] to confirm if a field is set.
type BetaRequestToolAdditionBlockToolUnionParam struct {
	OfToolReference       *BetaToolChangeToolReferenceParam       `json:",omitzero,inline"`
	OfMCPToolReference    *BetaToolChangeMCPToolReferenceParam    `json:",omitzero,inline"`
	OfMCPToolsetReference *BetaToolChangeMCPToolsetReferenceParam `json:",omitzero,inline"`
	paramUnion
}

func (u BetaRequestToolAdditionBlockToolUnionParam) MarshalJSON() ([]byte, error) {
	return param.MarshalUnion(u, u.OfToolReference, u.OfMCPToolReference, u.OfMCPToolsetReference)
}
func (u *BetaRequestToolAdditionBlockToolUnionParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, u)
}

func (u *BetaRequestToolAdditionBlockToolUnionParam) asAny() any {
	if !param.IsOmitted(u.OfToolReference) {
		return u.OfToolReference
	} else if !param.IsOmitted(u.OfMCPToolReference) {
		return u.OfMCPToolReference
	} else if !param.IsOmitted(u.OfMCPToolsetReference) {
		return u.OfMCPToolsetReference
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaRequestToolAdditionBlockToolUnionParam) GetName() *string {
	if vt := u.OfToolReference; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfMCPToolReference; vt != nil {
		return (*string)(&vt.Name)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaRequestToolAdditionBlockToolUnionParam) GetType() *string {
	if vt := u.OfToolReference; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfMCPToolReference; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfMCPToolsetReference; vt != nil {
		return (*string)(&vt.Type)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaRequestToolAdditionBlockToolUnionParam) GetServerName() *string {
	if vt := u.OfMCPToolReference; vt != nil {
		return (*string)(&vt.ServerName)
	} else if vt := u.OfMCPToolsetReference; vt != nil {
		return (*string)(&vt.ServerName)
	}
	return nil
}

func init() {
	apijson.RegisterUnion[BetaRequestToolAdditionBlockToolUnionParam](
		"type",
		apijson.Discriminator[BetaToolChangeToolReferenceParam]("tool_reference"),
		apijson.Discriminator[BetaToolChangeMCPToolReferenceParam]("mcp_tool_reference"),
		apijson.Discriminator[BetaToolChangeMCPToolsetReferenceParam]("mcp_toolset_reference"),
	)
}

// Mid-conversation directive to withdraw a tool.
//
// `tool` references a tool (or MCP toolset) by name from the request's `tools`; it
// is no longer offered to the model from this point in the conversation onward.
//
// The properties Tool, Type are required.
type BetaRequestToolRemovalBlockParam struct {
	// Reference to a single tool the caller declared directly in `tools[]`. Does not
	// accept the composed `{server}_{name}` form the server assigns to MCP-resolved
	// tools — use `mcp_tool_reference` or `mcp_toolset_reference` for those.
	Tool BetaRequestToolRemovalBlockToolUnionParam `json:"tool,omitzero" api:"required"`
	// Create a cache control breakpoint at this content block.
	CacheControl BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	// This field can be elided, and will marshal its zero value as "tool_removal".
	Type constant.ToolRemoval `json:"type" default:"tool_removal"`
	paramObj
}

func (r BetaRequestToolRemovalBlockParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaRequestToolRemovalBlockParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaRequestToolRemovalBlockParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Only one field can be non-zero.
//
// Use [param.IsOmitted] to confirm if a field is set.
type BetaRequestToolRemovalBlockToolUnionParam struct {
	OfToolReference       *BetaToolChangeToolReferenceParam       `json:",omitzero,inline"`
	OfMCPToolReference    *BetaToolChangeMCPToolReferenceParam    `json:",omitzero,inline"`
	OfMCPToolsetReference *BetaToolChangeMCPToolsetReferenceParam `json:",omitzero,inline"`
	paramUnion
}

func (u BetaRequestToolRemovalBlockToolUnionParam) MarshalJSON() ([]byte, error) {
	return param.MarshalUnion(u, u.OfToolReference, u.OfMCPToolReference, u.OfMCPToolsetReference)
}
func (u *BetaRequestToolRemovalBlockToolUnionParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, u)
}

func (u *BetaRequestToolRemovalBlockToolUnionParam) asAny() any {
	if !param.IsOmitted(u.OfToolReference) {
		return u.OfToolReference
	} else if !param.IsOmitted(u.OfMCPToolReference) {
		return u.OfMCPToolReference
	} else if !param.IsOmitted(u.OfMCPToolsetReference) {
		return u.OfMCPToolsetReference
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaRequestToolRemovalBlockToolUnionParam) GetName() *string {
	if vt := u.OfToolReference; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfMCPToolReference; vt != nil {
		return (*string)(&vt.Name)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaRequestToolRemovalBlockToolUnionParam) GetType() *string {
	if vt := u.OfToolReference; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfMCPToolReference; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfMCPToolsetReference; vt != nil {
		return (*string)(&vt.Type)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaRequestToolRemovalBlockToolUnionParam) GetServerName() *string {
	if vt := u.OfMCPToolReference; vt != nil {
		return (*string)(&vt.ServerName)
	} else if vt := u.OfMCPToolsetReference; vt != nil {
		return (*string)(&vt.ServerName)
	}
	return nil
}

func init() {
	apijson.RegisterUnion[BetaRequestToolRemovalBlockToolUnionParam](
		"type",
		apijson.Discriminator[BetaToolChangeToolReferenceParam]("tool_reference"),
		apijson.Discriminator[BetaToolChangeMCPToolReferenceParam]("mcp_tool_reference"),
		apijson.Discriminator[BetaToolChangeMCPToolsetReferenceParam]("mcp_toolset_reference"),
	)
}

// The properties Content, Source, Title, Type are required.
type BetaSearchResultBlockParam struct {
	Content []BetaTextBlockParam `json:"content,omitzero" api:"required"`
	Source  string               `json:"source" api:"required"`
	Title   string               `json:"title" api:"required"`
	// Create a cache control breakpoint at this content block.
	CacheControl BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	Citations    BetaCitationsConfigParam       `json:"citations,omitzero"`
	// This field can be elided, and will marshal its zero value as "search_result".
	Type constant.SearchResult `json:"type" default:"search_result"`
	paramObj
}

func (r BetaSearchResultBlockParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaSearchResultBlockParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaSearchResultBlockParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Tool invocation generated by a server-side tool.
type BetaServerToolCaller struct {
	ToolID string                         `json:"tool_id" api:"required"`
	Type   constant.CodeExecution20250825 `json:"type" default:"code_execution_20250825"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ToolID      respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaServerToolCaller) RawJSON() string { return r.JSON.raw }
func (r *BetaServerToolCaller) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// ToParam converts this BetaServerToolCaller to a BetaServerToolCallerParam.
//
// Warning: the fields of the param type will not be present. ToParam should only
// be used at the last possible moment before sending a request. Test for this with
// BetaServerToolCallerParam.Overrides()
func (r BetaServerToolCaller) ToParam() BetaServerToolCallerParam {
	return param.Override[BetaServerToolCallerParam](json.RawMessage(r.RawJSON()))
}

// Tool invocation generated by a server-side tool.
//
// The properties ToolID, Type are required.
type BetaServerToolCallerParam struct {
	ToolID string `json:"tool_id" api:"required"`
	// This field can be elided, and will marshal its zero value as
	// "code_execution_20250825".
	Type constant.CodeExecution20250825 `json:"type" default:"code_execution_20250825"`
	paramObj
}

func (r BetaServerToolCallerParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaServerToolCallerParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaServerToolCallerParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaServerToolCaller20260120 struct {
	ToolID string                         `json:"tool_id" api:"required"`
	Type   constant.CodeExecution20260120 `json:"type" default:"code_execution_20260120"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ToolID      respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaServerToolCaller20260120) RawJSON() string { return r.JSON.raw }
func (r *BetaServerToolCaller20260120) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// ToParam converts this BetaServerToolCaller20260120 to a
// BetaServerToolCaller20260120Param.
//
// Warning: the fields of the param type will not be present. ToParam should only
// be used at the last possible moment before sending a request. Test for this with
// BetaServerToolCaller20260120Param.Overrides()
func (r BetaServerToolCaller20260120) ToParam() BetaServerToolCaller20260120Param {
	return param.Override[BetaServerToolCaller20260120Param](json.RawMessage(r.RawJSON()))
}

// The properties ToolID, Type are required.
type BetaServerToolCaller20260120Param struct {
	ToolID string `json:"tool_id" api:"required"`
	// This field can be elided, and will marshal its zero value as
	// "code_execution_20260120".
	Type constant.CodeExecution20260120 `json:"type" default:"code_execution_20260120"`
	paramObj
}

func (r BetaServerToolCaller20260120Param) MarshalJSON() (data []byte, err error) {
	type shadow BetaServerToolCaller20260120Param
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaServerToolCaller20260120Param) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaServerToolUsage struct {
	// The number of web fetch tool requests.
	WebFetchRequests int64 `json:"web_fetch_requests" api:"required"`
	// The number of web search tool requests.
	WebSearchRequests int64 `json:"web_search_requests" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		WebFetchRequests  respjson.Field
		WebSearchRequests respjson.Field
		ExtraFields       map[string]respjson.Field
		raw               string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaServerToolUsage) RawJSON() string { return r.JSON.raw }
func (r *BetaServerToolUsage) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaServerToolUseBlock struct {
	ID    string `json:"id" api:"required"`
	Input any    `json:"input" api:"required"`
	// Any of "advisor", "web_search", "web_fetch", "code_execution",
	// "bash_code_execution", "text_editor_code_execution", "tool_search_tool_regex",
	// "tool_search_tool_bm25".
	Name BetaServerToolUseBlockName `json:"name" api:"required"`
	Type constant.ServerToolUse     `json:"type" default:"server_tool_use"`
	// Tool invocation directly from the model.
	Caller BetaServerToolUseBlockCallerUnion `json:"caller"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Input       respjson.Field
		Name        respjson.Field
		Type        respjson.Field
		Caller      respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaServerToolUseBlock) RawJSON() string { return r.JSON.raw }
func (r *BetaServerToolUseBlock) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaServerToolUseBlockName string

const (
	BetaServerToolUseBlockNameAdvisor                 BetaServerToolUseBlockName = "advisor"
	BetaServerToolUseBlockNameWebSearch               BetaServerToolUseBlockName = "web_search"
	BetaServerToolUseBlockNameWebFetch                BetaServerToolUseBlockName = "web_fetch"
	BetaServerToolUseBlockNameCodeExecution           BetaServerToolUseBlockName = "code_execution"
	BetaServerToolUseBlockNameBashCodeExecution       BetaServerToolUseBlockName = "bash_code_execution"
	BetaServerToolUseBlockNameTextEditorCodeExecution BetaServerToolUseBlockName = "text_editor_code_execution"
	BetaServerToolUseBlockNameToolSearchToolRegex     BetaServerToolUseBlockName = "tool_search_tool_regex"
	BetaServerToolUseBlockNameToolSearchToolBm25      BetaServerToolUseBlockName = "tool_search_tool_bm25"
)

// BetaServerToolUseBlockCallerUnion contains all possible properties and values
// from [BetaDirectCaller], [BetaServerToolCaller], [BetaServerToolCaller20260120].
//
// Use the [BetaServerToolUseBlockCallerUnion.AsAny] method to switch on the
// variant.
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
type BetaServerToolUseBlockCallerUnion struct {
	// Any of "direct", "code_execution_20250825", "code_execution_20260120".
	Type   string `json:"type"`
	ToolID string `json:"tool_id"`
	JSON   struct {
		Type   respjson.Field
		ToolID respjson.Field
		raw    string
	} `json:"-"`
}

// anyBetaServerToolUseBlockCaller is implemented by each variant of
// [BetaServerToolUseBlockCallerUnion] to add type safety for the return type of
// [BetaServerToolUseBlockCallerUnion.AsAny]
type anyBetaServerToolUseBlockCaller interface {
	implBetaServerToolUseBlockCallerUnion()
}

func (BetaDirectCaller) implBetaServerToolUseBlockCallerUnion()             {}
func (BetaServerToolCaller) implBetaServerToolUseBlockCallerUnion()         {}
func (BetaServerToolCaller20260120) implBetaServerToolUseBlockCallerUnion() {}

// Use the following switch statement to find the correct variant
//
//	switch variant := BetaServerToolUseBlockCallerUnion.AsAny().(type) {
//	case anthropic.BetaDirectCaller:
//	case anthropic.BetaServerToolCaller:
//	case anthropic.BetaServerToolCaller20260120:
//	default:
//	  fmt.Errorf("no variant present")
//	}
func (u BetaServerToolUseBlockCallerUnion) AsAny() anyBetaServerToolUseBlockCaller {
	switch u.Type {
	case "direct":
		return u.AsDirect()
	case "code_execution_20250825":
		return u.AsCodeExecution20250825()
	case "code_execution_20260120":
		return u.AsCodeExecution20260120()
	}
	return nil
}

func (u BetaServerToolUseBlockCallerUnion) AsDirect() (v BetaDirectCaller) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaServerToolUseBlockCallerUnion) AsCodeExecution20250825() (v BetaServerToolCaller) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaServerToolUseBlockCallerUnion) AsCodeExecution20260120() (v BetaServerToolCaller20260120) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u BetaServerToolUseBlockCallerUnion) RawJSON() string { return u.JSON.raw }

func (r *BetaServerToolUseBlockCallerUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties ID, Input, Name, Type are required.
type BetaServerToolUseBlockParam struct {
	ID    string `json:"id" api:"required"`
	Input any    `json:"input,omitzero" api:"required"`
	// Any of "advisor", "web_search", "web_fetch", "code_execution",
	// "bash_code_execution", "text_editor_code_execution", "tool_search_tool_regex",
	// "tool_search_tool_bm25".
	Name BetaServerToolUseBlockParamName `json:"name,omitzero" api:"required"`
	// Create a cache control breakpoint at this content block.
	CacheControl BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	// Tool invocation directly from the model.
	Caller BetaServerToolUseBlockParamCallerUnion `json:"caller,omitzero"`
	// This field can be elided, and will marshal its zero value as "server_tool_use".
	Type constant.ServerToolUse `json:"type" default:"server_tool_use"`
	paramObj
}

func (r BetaServerToolUseBlockParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaServerToolUseBlockParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaServerToolUseBlockParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaServerToolUseBlockParamName string

const (
	BetaServerToolUseBlockParamNameAdvisor                 BetaServerToolUseBlockParamName = "advisor"
	BetaServerToolUseBlockParamNameWebSearch               BetaServerToolUseBlockParamName = "web_search"
	BetaServerToolUseBlockParamNameWebFetch                BetaServerToolUseBlockParamName = "web_fetch"
	BetaServerToolUseBlockParamNameCodeExecution           BetaServerToolUseBlockParamName = "code_execution"
	BetaServerToolUseBlockParamNameBashCodeExecution       BetaServerToolUseBlockParamName = "bash_code_execution"
	BetaServerToolUseBlockParamNameTextEditorCodeExecution BetaServerToolUseBlockParamName = "text_editor_code_execution"
	BetaServerToolUseBlockParamNameToolSearchToolRegex     BetaServerToolUseBlockParamName = "tool_search_tool_regex"
	BetaServerToolUseBlockParamNameToolSearchToolBm25      BetaServerToolUseBlockParamName = "tool_search_tool_bm25"
)

// Only one field can be non-zero.
//
// Use [param.IsOmitted] to confirm if a field is set.
type BetaServerToolUseBlockParamCallerUnion struct {
	OfDirect                *BetaDirectCallerParam             `json:",omitzero,inline"`
	OfCodeExecution20250825 *BetaServerToolCallerParam         `json:",omitzero,inline"`
	OfCodeExecution20260120 *BetaServerToolCaller20260120Param `json:",omitzero,inline"`
	paramUnion
}

func (u BetaServerToolUseBlockParamCallerUnion) MarshalJSON() ([]byte, error) {
	return param.MarshalUnion(u, u.OfDirect, u.OfCodeExecution20250825, u.OfCodeExecution20260120)
}
func (u *BetaServerToolUseBlockParamCallerUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, u)
}

func (u *BetaServerToolUseBlockParamCallerUnion) asAny() any {
	if !param.IsOmitted(u.OfDirect) {
		return u.OfDirect
	} else if !param.IsOmitted(u.OfCodeExecution20250825) {
		return u.OfCodeExecution20250825
	} else if !param.IsOmitted(u.OfCodeExecution20260120) {
		return u.OfCodeExecution20260120
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaServerToolUseBlockParamCallerUnion) GetType() *string {
	if vt := u.OfDirect; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfCodeExecution20250825; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfCodeExecution20260120; vt != nil {
		return (*string)(&vt.Type)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaServerToolUseBlockParamCallerUnion) GetToolID() *string {
	if vt := u.OfCodeExecution20250825; vt != nil {
		return (*string)(&vt.ToolID)
	} else if vt := u.OfCodeExecution20260120; vt != nil {
		return (*string)(&vt.ToolID)
	}
	return nil
}

func init() {
	apijson.RegisterUnion[BetaServerToolUseBlockParamCallerUnion](
		"type",
		apijson.Discriminator[BetaDirectCallerParam]("direct"),
		apijson.Discriminator[BetaServerToolCallerParam]("code_execution_20250825"),
		apijson.Discriminator[BetaServerToolCaller20260120Param]("code_execution_20260120"),
	)
}

type BetaSignatureDelta struct {
	// The `signature` for this thinking block: an opaque value used to verify that the
	// block was generated by Claude when it is passed back to the API. Delivered in a
	// `signature_delta` event just before the block's `content_block_stop` event.
	Signature string                  `json:"signature" api:"required"`
	Type      constant.SignatureDelta `json:"type" default:"signature_delta"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Signature   respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaSignatureDelta) RawJSON() string { return r.JSON.raw }
func (r *BetaSignatureDelta) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Specification for a skill to be loaded in a container (request model).
//
// The properties SkillID, Type are required.
type BetaSkillParams struct {
	// Skill ID
	SkillID string `json:"skill_id" api:"required"`
	// Type of skill - either 'anthropic' (built-in) or 'custom' (user-defined)
	//
	// Any of "anthropic", "custom".
	Type BetaSkillParamsType `json:"type,omitzero" api:"required"`
	// Skill version or 'latest' for most recent version
	Version param.Opt[string] `json:"version,omitzero"`
	paramObj
}

func (r BetaSkillParams) MarshalJSON() (data []byte, err error) {
	type shadow BetaSkillParams
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaSkillParams) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Type of skill - either 'anthropic' (built-in) or 'custom' (user-defined)
type BetaSkillParamsType string

const (
	BetaSkillParamsTypeAnthropic BetaSkillParamsType = "anthropic"
	BetaSkillParamsTypeCustom    BetaSkillParamsType = "custom"
)

type BetaStopReason string

const (
	BetaStopReasonEndTurn                    BetaStopReason = "end_turn"
	BetaStopReasonMaxTokens                  BetaStopReason = "max_tokens"
	BetaStopReasonStopSequence               BetaStopReason = "stop_sequence"
	BetaStopReasonToolUse                    BetaStopReason = "tool_use"
	BetaStopReasonPauseTurn                  BetaStopReason = "pause_turn"
	BetaStopReasonCompaction                 BetaStopReason = "compaction"
	BetaStopReasonRefusal                    BetaStopReason = "refusal"
	BetaStopReasonModelContextWindowExceeded BetaStopReason = "model_context_window_exceeded"
)

// Per-message output configuration on a role:"system" input message.
//
// Fields here apply per-turn; `format` remains top-level only. An empty `{}` is
// accepted on a message that carries content; a message with neither content nor
// output_config fields is rejected.
type BetaSystemMessageOutputConfigParam struct {
	// All possible effort levels.
	//
	// Any of "low", "medium", "high", "xhigh", "max".
	Effort BetaSystemMessageOutputConfigEffort `json:"effort,omitzero"`
	paramObj
}

func (r BetaSystemMessageOutputConfigParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaSystemMessageOutputConfigParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaSystemMessageOutputConfigParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// All possible effort levels.
type BetaSystemMessageOutputConfigEffort string

const (
	BetaSystemMessageOutputConfigEffortLow    BetaSystemMessageOutputConfigEffort = "low"
	BetaSystemMessageOutputConfigEffortMedium BetaSystemMessageOutputConfigEffort = "medium"
	BetaSystemMessageOutputConfigEffortHigh   BetaSystemMessageOutputConfigEffort = "high"
	BetaSystemMessageOutputConfigEffortXhigh  BetaSystemMessageOutputConfigEffort = "xhigh"
	BetaSystemMessageOutputConfigEffortMax    BetaSystemMessageOutputConfigEffort = "max"
)

type BetaTextBlock struct {
	// Citations supporting the text block.
	//
	// The type of citation returned will depend on the type of document being cited.
	// Citing a PDF results in `page_location`, plain text results in `char_location`,
	// and content document results in `content_block_location`.
	Citations []BetaTextCitationUnion `json:"citations" api:"required"`
	Text      string                  `json:"text" api:"required"`
	Type      constant.Text           `json:"type" default:"text"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Citations   respjson.Field
		Text        respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaTextBlock) RawJSON() string { return r.JSON.raw }
func (r *BetaTextBlock) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties Text, Type are required.
type BetaTextBlockParam struct {
	Text      string                       `json:"text" api:"required"`
	Citations []BetaTextCitationParamUnion `json:"citations,omitzero"`
	// Create a cache control breakpoint at this content block.
	CacheControl BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	// This field can be elided, and will marshal its zero value as "text".
	Type constant.Text `json:"type" default:"text"`
	paramObj
}

func (r BetaTextBlockParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaTextBlockParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaTextBlockParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// BetaTextCitationUnion contains all possible properties and values from
// [BetaCitationCharLocation], [BetaCitationPageLocation],
// [BetaCitationContentBlockLocation], [BetaCitationsWebSearchResultLocation],
// [BetaCitationSearchResultLocation].
//
// Use the [BetaTextCitationUnion.AsAny] method to switch on the variant.
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
type BetaTextCitationUnion struct {
	CitedText     string `json:"cited_text"`
	DocumentIndex int64  `json:"document_index"`
	DocumentTitle string `json:"document_title"`
	// This field is from variant [BetaCitationCharLocation].
	EndCharIndex int64  `json:"end_char_index"`
	FileID       string `json:"file_id"`
	// This field is from variant [BetaCitationCharLocation].
	StartCharIndex int64 `json:"start_char_index"`
	// Any of "char_location", "page_location", "content_block_location",
	// "web_search_result_location", "search_result_location".
	Type string `json:"type"`
	// This field is from variant [BetaCitationPageLocation].
	EndPageNumber int64 `json:"end_page_number"`
	// This field is from variant [BetaCitationPageLocation].
	StartPageNumber int64 `json:"start_page_number"`
	EndBlockIndex   int64 `json:"end_block_index"`
	StartBlockIndex int64 `json:"start_block_index"`
	// This field is from variant [BetaCitationsWebSearchResultLocation].
	EncryptedIndex string `json:"encrypted_index"`
	Title          string `json:"title"`
	// This field is from variant [BetaCitationsWebSearchResultLocation].
	URL string `json:"url"`
	// This field is from variant [BetaCitationSearchResultLocation].
	SearchResultIndex int64 `json:"search_result_index"`
	// This field is from variant [BetaCitationSearchResultLocation].
	Source string `json:"source"`
	JSON   struct {
		CitedText         respjson.Field
		DocumentIndex     respjson.Field
		DocumentTitle     respjson.Field
		EndCharIndex      respjson.Field
		FileID            respjson.Field
		StartCharIndex    respjson.Field
		Type              respjson.Field
		EndPageNumber     respjson.Field
		StartPageNumber   respjson.Field
		EndBlockIndex     respjson.Field
		StartBlockIndex   respjson.Field
		EncryptedIndex    respjson.Field
		Title             respjson.Field
		URL               respjson.Field
		SearchResultIndex respjson.Field
		Source            respjson.Field
		raw               string
	} `json:"-"`
}

// anyBetaTextCitation is implemented by each variant of [BetaTextCitationUnion] to
// add type safety for the return type of [BetaTextCitationUnion.AsAny]
type anyBetaTextCitation interface {
	implBetaTextCitationUnion()
	toParamUnion() BetaTextCitationParamUnion
}

func (BetaCitationCharLocation) implBetaTextCitationUnion()             {}
func (BetaCitationPageLocation) implBetaTextCitationUnion()             {}
func (BetaCitationContentBlockLocation) implBetaTextCitationUnion()     {}
func (BetaCitationsWebSearchResultLocation) implBetaTextCitationUnion() {}
func (BetaCitationSearchResultLocation) implBetaTextCitationUnion()     {}

// Use the following switch statement to find the correct variant
//
//	switch variant := BetaTextCitationUnion.AsAny().(type) {
//	case anthropic.BetaCitationCharLocation:
//	case anthropic.BetaCitationPageLocation:
//	case anthropic.BetaCitationContentBlockLocation:
//	case anthropic.BetaCitationsWebSearchResultLocation:
//	case anthropic.BetaCitationSearchResultLocation:
//	default:
//	  fmt.Errorf("no variant present")
//	}
func (u BetaTextCitationUnion) AsAny() anyBetaTextCitation {
	switch u.Type {
	case "char_location":
		return u.AsCharLocation()
	case "page_location":
		return u.AsPageLocation()
	case "content_block_location":
		return u.AsContentBlockLocation()
	case "web_search_result_location":
		return u.AsWebSearchResultLocation()
	case "search_result_location":
		return u.AsSearchResultLocation()
	}
	return nil
}

func (u BetaTextCitationUnion) AsCharLocation() (v BetaCitationCharLocation) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaTextCitationUnion) AsPageLocation() (v BetaCitationPageLocation) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaTextCitationUnion) AsContentBlockLocation() (v BetaCitationContentBlockLocation) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaTextCitationUnion) AsWebSearchResultLocation() (v BetaCitationsWebSearchResultLocation) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaTextCitationUnion) AsSearchResultLocation() (v BetaCitationSearchResultLocation) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u BetaTextCitationUnion) RawJSON() string { return u.JSON.raw }

func (r *BetaTextCitationUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Only one field can be non-zero.
//
// Use [param.IsOmitted] to confirm if a field is set.
type BetaTextCitationParamUnion struct {
	OfCharLocation            *BetaCitationCharLocationParam            `json:",omitzero,inline"`
	OfPageLocation            *BetaCitationPageLocationParam            `json:",omitzero,inline"`
	OfContentBlockLocation    *BetaCitationContentBlockLocationParam    `json:",omitzero,inline"`
	OfWebSearchResultLocation *BetaCitationWebSearchResultLocationParam `json:",omitzero,inline"`
	OfSearchResultLocation    *BetaCitationSearchResultLocationParam    `json:",omitzero,inline"`
	paramUnion
}

func (u BetaTextCitationParamUnion) MarshalJSON() ([]byte, error) {
	return param.MarshalUnion(u, u.OfCharLocation,
		u.OfPageLocation,
		u.OfContentBlockLocation,
		u.OfWebSearchResultLocation,
		u.OfSearchResultLocation)
}
func (u *BetaTextCitationParamUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, u)
}

func (u *BetaTextCitationParamUnion) asAny() any {
	if !param.IsOmitted(u.OfCharLocation) {
		return u.OfCharLocation
	} else if !param.IsOmitted(u.OfPageLocation) {
		return u.OfPageLocation
	} else if !param.IsOmitted(u.OfContentBlockLocation) {
		return u.OfContentBlockLocation
	} else if !param.IsOmitted(u.OfWebSearchResultLocation) {
		return u.OfWebSearchResultLocation
	} else if !param.IsOmitted(u.OfSearchResultLocation) {
		return u.OfSearchResultLocation
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaTextCitationParamUnion) GetEndCharIndex() *int64 {
	if vt := u.OfCharLocation; vt != nil {
		return &vt.EndCharIndex
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaTextCitationParamUnion) GetStartCharIndex() *int64 {
	if vt := u.OfCharLocation; vt != nil {
		return &vt.StartCharIndex
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaTextCitationParamUnion) GetEndPageNumber() *int64 {
	if vt := u.OfPageLocation; vt != nil {
		return &vt.EndPageNumber
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaTextCitationParamUnion) GetStartPageNumber() *int64 {
	if vt := u.OfPageLocation; vt != nil {
		return &vt.StartPageNumber
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaTextCitationParamUnion) GetEncryptedIndex() *string {
	if vt := u.OfWebSearchResultLocation; vt != nil {
		return &vt.EncryptedIndex
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaTextCitationParamUnion) GetURL() *string {
	if vt := u.OfWebSearchResultLocation; vt != nil {
		return &vt.URL
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaTextCitationParamUnion) GetSearchResultIndex() *int64 {
	if vt := u.OfSearchResultLocation; vt != nil {
		return &vt.SearchResultIndex
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaTextCitationParamUnion) GetSource() *string {
	if vt := u.OfSearchResultLocation; vt != nil {
		return &vt.Source
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaTextCitationParamUnion) GetCitedText() *string {
	if vt := u.OfCharLocation; vt != nil {
		return (*string)(&vt.CitedText)
	} else if vt := u.OfPageLocation; vt != nil {
		return (*string)(&vt.CitedText)
	} else if vt := u.OfContentBlockLocation; vt != nil {
		return (*string)(&vt.CitedText)
	} else if vt := u.OfWebSearchResultLocation; vt != nil {
		return (*string)(&vt.CitedText)
	} else if vt := u.OfSearchResultLocation; vt != nil {
		return (*string)(&vt.CitedText)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaTextCitationParamUnion) GetDocumentIndex() *int64 {
	if vt := u.OfCharLocation; vt != nil {
		return (*int64)(&vt.DocumentIndex)
	} else if vt := u.OfPageLocation; vt != nil {
		return (*int64)(&vt.DocumentIndex)
	} else if vt := u.OfContentBlockLocation; vt != nil {
		return (*int64)(&vt.DocumentIndex)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaTextCitationParamUnion) GetDocumentTitle() *string {
	if vt := u.OfCharLocation; vt != nil && vt.DocumentTitle.Valid() {
		return &vt.DocumentTitle.Value
	} else if vt := u.OfPageLocation; vt != nil && vt.DocumentTitle.Valid() {
		return &vt.DocumentTitle.Value
	} else if vt := u.OfContentBlockLocation; vt != nil && vt.DocumentTitle.Valid() {
		return &vt.DocumentTitle.Value
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaTextCitationParamUnion) GetType() *string {
	if vt := u.OfCharLocation; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfPageLocation; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfContentBlockLocation; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfWebSearchResultLocation; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfSearchResultLocation; vt != nil {
		return (*string)(&vt.Type)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaTextCitationParamUnion) GetEndBlockIndex() *int64 {
	if vt := u.OfContentBlockLocation; vt != nil {
		return (*int64)(&vt.EndBlockIndex)
	} else if vt := u.OfSearchResultLocation; vt != nil {
		return (*int64)(&vt.EndBlockIndex)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaTextCitationParamUnion) GetStartBlockIndex() *int64 {
	if vt := u.OfContentBlockLocation; vt != nil {
		return (*int64)(&vt.StartBlockIndex)
	} else if vt := u.OfSearchResultLocation; vt != nil {
		return (*int64)(&vt.StartBlockIndex)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaTextCitationParamUnion) GetTitle() *string {
	if vt := u.OfWebSearchResultLocation; vt != nil && vt.Title.Valid() {
		return &vt.Title.Value
	} else if vt := u.OfSearchResultLocation; vt != nil && vt.Title.Valid() {
		return &vt.Title.Value
	}
	return nil
}

func init() {
	apijson.RegisterUnion[BetaTextCitationParamUnion](
		"type",
		apijson.Discriminator[BetaCitationCharLocationParam]("char_location"),
		apijson.Discriminator[BetaCitationPageLocationParam]("page_location"),
		apijson.Discriminator[BetaCitationContentBlockLocationParam]("content_block_location"),
		apijson.Discriminator[BetaCitationWebSearchResultLocationParam]("web_search_result_location"),
		apijson.Discriminator[BetaCitationSearchResultLocationParam]("search_result_location"),
	)
}

type BetaTextDelta struct {
	Text string             `json:"text" api:"required"`
	Type constant.TextDelta `json:"type" default:"text_delta"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Text        respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaTextDelta) RawJSON() string { return r.JSON.raw }
func (r *BetaTextDelta) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaTextEditorCodeExecutionCreateResultBlock struct {
	IsFileUpdate bool                                         `json:"is_file_update" api:"required"`
	Type         constant.TextEditorCodeExecutionCreateResult `json:"type" default:"text_editor_code_execution_create_result"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		IsFileUpdate respjson.Field
		Type         respjson.Field
		ExtraFields  map[string]respjson.Field
		raw          string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaTextEditorCodeExecutionCreateResultBlock) RawJSON() string { return r.JSON.raw }
func (r *BetaTextEditorCodeExecutionCreateResultBlock) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties IsFileUpdate, Type are required.
type BetaTextEditorCodeExecutionCreateResultBlockParam struct {
	IsFileUpdate bool `json:"is_file_update" api:"required"`
	// This field can be elided, and will marshal its zero value as
	// "text_editor_code_execution_create_result".
	Type constant.TextEditorCodeExecutionCreateResult `json:"type" default:"text_editor_code_execution_create_result"`
	paramObj
}

func (r BetaTextEditorCodeExecutionCreateResultBlockParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaTextEditorCodeExecutionCreateResultBlockParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaTextEditorCodeExecutionCreateResultBlockParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaTextEditorCodeExecutionStrReplaceResultBlock struct {
	Lines    []string                                         `json:"lines" api:"required"`
	NewLines int64                                            `json:"new_lines" api:"required"`
	NewStart int64                                            `json:"new_start" api:"required"`
	OldLines int64                                            `json:"old_lines" api:"required"`
	OldStart int64                                            `json:"old_start" api:"required"`
	Type     constant.TextEditorCodeExecutionStrReplaceResult `json:"type" default:"text_editor_code_execution_str_replace_result"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Lines       respjson.Field
		NewLines    respjson.Field
		NewStart    respjson.Field
		OldLines    respjson.Field
		OldStart    respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaTextEditorCodeExecutionStrReplaceResultBlock) RawJSON() string { return r.JSON.raw }
func (r *BetaTextEditorCodeExecutionStrReplaceResultBlock) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The property Type is required.
type BetaTextEditorCodeExecutionStrReplaceResultBlockParam struct {
	NewLines param.Opt[int64] `json:"new_lines,omitzero"`
	NewStart param.Opt[int64] `json:"new_start,omitzero"`
	OldLines param.Opt[int64] `json:"old_lines,omitzero"`
	OldStart param.Opt[int64] `json:"old_start,omitzero"`
	Lines    []string         `json:"lines,omitzero"`
	// This field can be elided, and will marshal its zero value as
	// "text_editor_code_execution_str_replace_result".
	Type constant.TextEditorCodeExecutionStrReplaceResult `json:"type" default:"text_editor_code_execution_str_replace_result"`
	paramObj
}

func (r BetaTextEditorCodeExecutionStrReplaceResultBlockParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaTextEditorCodeExecutionStrReplaceResultBlockParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaTextEditorCodeExecutionStrReplaceResultBlockParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaTextEditorCodeExecutionToolResultBlock struct {
	Content   BetaTextEditorCodeExecutionToolResultBlockContentUnion `json:"content" api:"required"`
	ToolUseID string                                                 `json:"tool_use_id" api:"required"`
	Type      constant.TextEditorCodeExecutionToolResult             `json:"type" default:"text_editor_code_execution_tool_result"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Content     respjson.Field
		ToolUseID   respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaTextEditorCodeExecutionToolResultBlock) RawJSON() string { return r.JSON.raw }
func (r *BetaTextEditorCodeExecutionToolResultBlock) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// BetaTextEditorCodeExecutionToolResultBlockContentUnion contains all possible
// properties and values from [BetaTextEditorCodeExecutionToolResultError],
// [BetaTextEditorCodeExecutionViewResultBlock],
// [BetaTextEditorCodeExecutionCreateResultBlock],
// [BetaTextEditorCodeExecutionStrReplaceResultBlock].
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
type BetaTextEditorCodeExecutionToolResultBlockContentUnion struct {
	// This field is from variant [BetaTextEditorCodeExecutionToolResultError].
	ErrorCode BetaTextEditorCodeExecutionToolResultErrorErrorCode `json:"error_code"`
	// This field is from variant [BetaTextEditorCodeExecutionToolResultError].
	ErrorMessage string `json:"error_message"`
	Type         string `json:"type"`
	// This field is from variant [BetaTextEditorCodeExecutionViewResultBlock].
	Content string `json:"content"`
	// This field is from variant [BetaTextEditorCodeExecutionViewResultBlock].
	FileType BetaTextEditorCodeExecutionViewResultBlockFileType `json:"file_type"`
	// This field is from variant [BetaTextEditorCodeExecutionViewResultBlock].
	NumLines int64 `json:"num_lines"`
	// This field is from variant [BetaTextEditorCodeExecutionViewResultBlock].
	StartLine int64 `json:"start_line"`
	// This field is from variant [BetaTextEditorCodeExecutionViewResultBlock].
	TotalLines int64 `json:"total_lines"`
	// This field is from variant [BetaTextEditorCodeExecutionCreateResultBlock].
	IsFileUpdate bool `json:"is_file_update"`
	// This field is from variant [BetaTextEditorCodeExecutionStrReplaceResultBlock].
	Lines []string `json:"lines"`
	// This field is from variant [BetaTextEditorCodeExecutionStrReplaceResultBlock].
	NewLines int64 `json:"new_lines"`
	// This field is from variant [BetaTextEditorCodeExecutionStrReplaceResultBlock].
	NewStart int64 `json:"new_start"`
	// This field is from variant [BetaTextEditorCodeExecutionStrReplaceResultBlock].
	OldLines int64 `json:"old_lines"`
	// This field is from variant [BetaTextEditorCodeExecutionStrReplaceResultBlock].
	OldStart int64 `json:"old_start"`
	JSON     struct {
		ErrorCode    respjson.Field
		ErrorMessage respjson.Field
		Type         respjson.Field
		Content      respjson.Field
		FileType     respjson.Field
		NumLines     respjson.Field
		StartLine    respjson.Field
		TotalLines   respjson.Field
		IsFileUpdate respjson.Field
		Lines        respjson.Field
		NewLines     respjson.Field
		NewStart     respjson.Field
		OldLines     respjson.Field
		OldStart     respjson.Field
		raw          string
	} `json:"-"`
}

func (u BetaTextEditorCodeExecutionToolResultBlockContentUnion) AsResponseTextEditorCodeExecutionToolResultError() (v BetaTextEditorCodeExecutionToolResultError) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaTextEditorCodeExecutionToolResultBlockContentUnion) AsResponseTextEditorCodeExecutionViewResultBlock() (v BetaTextEditorCodeExecutionViewResultBlock) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaTextEditorCodeExecutionToolResultBlockContentUnion) AsResponseTextEditorCodeExecutionCreateResultBlock() (v BetaTextEditorCodeExecutionCreateResultBlock) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaTextEditorCodeExecutionToolResultBlockContentUnion) AsResponseTextEditorCodeExecutionStrReplaceResultBlock() (v BetaTextEditorCodeExecutionStrReplaceResultBlock) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u BetaTextEditorCodeExecutionToolResultBlockContentUnion) RawJSON() string { return u.JSON.raw }

func (r *BetaTextEditorCodeExecutionToolResultBlockContentUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties Content, ToolUseID, Type are required.
type BetaTextEditorCodeExecutionToolResultBlockParam struct {
	Content   BetaTextEditorCodeExecutionToolResultBlockParamContentUnion `json:"content,omitzero" api:"required"`
	ToolUseID string                                                      `json:"tool_use_id" api:"required"`
	// Create a cache control breakpoint at this content block.
	CacheControl BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	// This field can be elided, and will marshal its zero value as
	// "text_editor_code_execution_tool_result".
	Type constant.TextEditorCodeExecutionToolResult `json:"type" default:"text_editor_code_execution_tool_result"`
	paramObj
}

func (r BetaTextEditorCodeExecutionToolResultBlockParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaTextEditorCodeExecutionToolResultBlockParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaTextEditorCodeExecutionToolResultBlockParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Only one field can be non-zero.
//
// Use [param.IsOmitted] to confirm if a field is set.
type BetaTextEditorCodeExecutionToolResultBlockParamContentUnion struct {
	OfRequestTextEditorCodeExecutionToolResultError       *BetaTextEditorCodeExecutionToolResultErrorParam       `json:",omitzero,inline"`
	OfRequestTextEditorCodeExecutionViewResultBlock       *BetaTextEditorCodeExecutionViewResultBlockParam       `json:",omitzero,inline"`
	OfRequestTextEditorCodeExecutionCreateResultBlock     *BetaTextEditorCodeExecutionCreateResultBlockParam     `json:",omitzero,inline"`
	OfRequestTextEditorCodeExecutionStrReplaceResultBlock *BetaTextEditorCodeExecutionStrReplaceResultBlockParam `json:",omitzero,inline"`
	paramUnion
}

func (u BetaTextEditorCodeExecutionToolResultBlockParamContentUnion) MarshalJSON() ([]byte, error) {
	return param.MarshalUnion(u, u.OfRequestTextEditorCodeExecutionToolResultError, u.OfRequestTextEditorCodeExecutionViewResultBlock, u.OfRequestTextEditorCodeExecutionCreateResultBlock, u.OfRequestTextEditorCodeExecutionStrReplaceResultBlock)
}
func (u *BetaTextEditorCodeExecutionToolResultBlockParamContentUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, u)
}

func (u *BetaTextEditorCodeExecutionToolResultBlockParamContentUnion) asAny() any {
	if !param.IsOmitted(u.OfRequestTextEditorCodeExecutionToolResultError) {
		return u.OfRequestTextEditorCodeExecutionToolResultError
	} else if !param.IsOmitted(u.OfRequestTextEditorCodeExecutionViewResultBlock) {
		return u.OfRequestTextEditorCodeExecutionViewResultBlock
	} else if !param.IsOmitted(u.OfRequestTextEditorCodeExecutionCreateResultBlock) {
		return u.OfRequestTextEditorCodeExecutionCreateResultBlock
	} else if !param.IsOmitted(u.OfRequestTextEditorCodeExecutionStrReplaceResultBlock) {
		return u.OfRequestTextEditorCodeExecutionStrReplaceResultBlock
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaTextEditorCodeExecutionToolResultBlockParamContentUnion) GetErrorCode() *string {
	if vt := u.OfRequestTextEditorCodeExecutionToolResultError; vt != nil {
		return (*string)(&vt.ErrorCode)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaTextEditorCodeExecutionToolResultBlockParamContentUnion) GetErrorMessage() *string {
	if vt := u.OfRequestTextEditorCodeExecutionToolResultError; vt != nil && vt.ErrorMessage.Valid() {
		return &vt.ErrorMessage.Value
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaTextEditorCodeExecutionToolResultBlockParamContentUnion) GetContent() *string {
	if vt := u.OfRequestTextEditorCodeExecutionViewResultBlock; vt != nil {
		return &vt.Content
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaTextEditorCodeExecutionToolResultBlockParamContentUnion) GetFileType() *string {
	if vt := u.OfRequestTextEditorCodeExecutionViewResultBlock; vt != nil {
		return (*string)(&vt.FileType)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaTextEditorCodeExecutionToolResultBlockParamContentUnion) GetNumLines() *int64 {
	if vt := u.OfRequestTextEditorCodeExecutionViewResultBlock; vt != nil && vt.NumLines.Valid() {
		return &vt.NumLines.Value
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaTextEditorCodeExecutionToolResultBlockParamContentUnion) GetStartLine() *int64 {
	if vt := u.OfRequestTextEditorCodeExecutionViewResultBlock; vt != nil && vt.StartLine.Valid() {
		return &vt.StartLine.Value
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaTextEditorCodeExecutionToolResultBlockParamContentUnion) GetTotalLines() *int64 {
	if vt := u.OfRequestTextEditorCodeExecutionViewResultBlock; vt != nil && vt.TotalLines.Valid() {
		return &vt.TotalLines.Value
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaTextEditorCodeExecutionToolResultBlockParamContentUnion) GetIsFileUpdate() *bool {
	if vt := u.OfRequestTextEditorCodeExecutionCreateResultBlock; vt != nil {
		return &vt.IsFileUpdate
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaTextEditorCodeExecutionToolResultBlockParamContentUnion) GetLines() []string {
	if vt := u.OfRequestTextEditorCodeExecutionStrReplaceResultBlock; vt != nil {
		return vt.Lines
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaTextEditorCodeExecutionToolResultBlockParamContentUnion) GetNewLines() *int64 {
	if vt := u.OfRequestTextEditorCodeExecutionStrReplaceResultBlock; vt != nil && vt.NewLines.Valid() {
		return &vt.NewLines.Value
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaTextEditorCodeExecutionToolResultBlockParamContentUnion) GetNewStart() *int64 {
	if vt := u.OfRequestTextEditorCodeExecutionStrReplaceResultBlock; vt != nil && vt.NewStart.Valid() {
		return &vt.NewStart.Value
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaTextEditorCodeExecutionToolResultBlockParamContentUnion) GetOldLines() *int64 {
	if vt := u.OfRequestTextEditorCodeExecutionStrReplaceResultBlock; vt != nil && vt.OldLines.Valid() {
		return &vt.OldLines.Value
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaTextEditorCodeExecutionToolResultBlockParamContentUnion) GetOldStart() *int64 {
	if vt := u.OfRequestTextEditorCodeExecutionStrReplaceResultBlock; vt != nil && vt.OldStart.Valid() {
		return &vt.OldStart.Value
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaTextEditorCodeExecutionToolResultBlockParamContentUnion) GetType() *string {
	if vt := u.OfRequestTextEditorCodeExecutionToolResultError; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfRequestTextEditorCodeExecutionViewResultBlock; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfRequestTextEditorCodeExecutionCreateResultBlock; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfRequestTextEditorCodeExecutionStrReplaceResultBlock; vt != nil {
		return (*string)(&vt.Type)
	}
	return nil
}

type BetaTextEditorCodeExecutionToolResultError struct {
	// Any of "invalid_tool_input", "unavailable", "too_many_requests",
	// "execution_time_exceeded", "file_not_found".
	ErrorCode    BetaTextEditorCodeExecutionToolResultErrorErrorCode `json:"error_code" api:"required"`
	ErrorMessage string                                              `json:"error_message" api:"required"`
	Type         constant.TextEditorCodeExecutionToolResultError     `json:"type" default:"text_editor_code_execution_tool_result_error"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ErrorCode    respjson.Field
		ErrorMessage respjson.Field
		Type         respjson.Field
		ExtraFields  map[string]respjson.Field
		raw          string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaTextEditorCodeExecutionToolResultError) RawJSON() string { return r.JSON.raw }
func (r *BetaTextEditorCodeExecutionToolResultError) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaTextEditorCodeExecutionToolResultErrorErrorCode string

const (
	BetaTextEditorCodeExecutionToolResultErrorErrorCodeInvalidToolInput      BetaTextEditorCodeExecutionToolResultErrorErrorCode = "invalid_tool_input"
	BetaTextEditorCodeExecutionToolResultErrorErrorCodeUnavailable           BetaTextEditorCodeExecutionToolResultErrorErrorCode = "unavailable"
	BetaTextEditorCodeExecutionToolResultErrorErrorCodeTooManyRequests       BetaTextEditorCodeExecutionToolResultErrorErrorCode = "too_many_requests"
	BetaTextEditorCodeExecutionToolResultErrorErrorCodeExecutionTimeExceeded BetaTextEditorCodeExecutionToolResultErrorErrorCode = "execution_time_exceeded"
	BetaTextEditorCodeExecutionToolResultErrorErrorCodeFileNotFound          BetaTextEditorCodeExecutionToolResultErrorErrorCode = "file_not_found"
)

// The properties ErrorCode, Type are required.
type BetaTextEditorCodeExecutionToolResultErrorParam struct {
	// Any of "invalid_tool_input", "unavailable", "too_many_requests",
	// "execution_time_exceeded", "file_not_found".
	ErrorCode    BetaTextEditorCodeExecutionToolResultErrorParamErrorCode `json:"error_code,omitzero" api:"required"`
	ErrorMessage param.Opt[string]                                        `json:"error_message,omitzero"`
	// This field can be elided, and will marshal its zero value as
	// "text_editor_code_execution_tool_result_error".
	Type constant.TextEditorCodeExecutionToolResultError `json:"type" default:"text_editor_code_execution_tool_result_error"`
	paramObj
}

func (r BetaTextEditorCodeExecutionToolResultErrorParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaTextEditorCodeExecutionToolResultErrorParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaTextEditorCodeExecutionToolResultErrorParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaTextEditorCodeExecutionToolResultErrorParamErrorCode string

const (
	BetaTextEditorCodeExecutionToolResultErrorParamErrorCodeInvalidToolInput      BetaTextEditorCodeExecutionToolResultErrorParamErrorCode = "invalid_tool_input"
	BetaTextEditorCodeExecutionToolResultErrorParamErrorCodeUnavailable           BetaTextEditorCodeExecutionToolResultErrorParamErrorCode = "unavailable"
	BetaTextEditorCodeExecutionToolResultErrorParamErrorCodeTooManyRequests       BetaTextEditorCodeExecutionToolResultErrorParamErrorCode = "too_many_requests"
	BetaTextEditorCodeExecutionToolResultErrorParamErrorCodeExecutionTimeExceeded BetaTextEditorCodeExecutionToolResultErrorParamErrorCode = "execution_time_exceeded"
	BetaTextEditorCodeExecutionToolResultErrorParamErrorCodeFileNotFound          BetaTextEditorCodeExecutionToolResultErrorParamErrorCode = "file_not_found"
)

type BetaTextEditorCodeExecutionViewResultBlock struct {
	Content string `json:"content" api:"required"`
	// Any of "text", "image", "pdf".
	FileType   BetaTextEditorCodeExecutionViewResultBlockFileType `json:"file_type" api:"required"`
	NumLines   int64                                              `json:"num_lines" api:"required"`
	StartLine  int64                                              `json:"start_line" api:"required"`
	TotalLines int64                                              `json:"total_lines" api:"required"`
	Type       constant.TextEditorCodeExecutionViewResult         `json:"type" default:"text_editor_code_execution_view_result"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Content     respjson.Field
		FileType    respjson.Field
		NumLines    respjson.Field
		StartLine   respjson.Field
		TotalLines  respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaTextEditorCodeExecutionViewResultBlock) RawJSON() string { return r.JSON.raw }
func (r *BetaTextEditorCodeExecutionViewResultBlock) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaTextEditorCodeExecutionViewResultBlockFileType string

const (
	BetaTextEditorCodeExecutionViewResultBlockFileTypeText  BetaTextEditorCodeExecutionViewResultBlockFileType = "text"
	BetaTextEditorCodeExecutionViewResultBlockFileTypeImage BetaTextEditorCodeExecutionViewResultBlockFileType = "image"
	BetaTextEditorCodeExecutionViewResultBlockFileTypePDF   BetaTextEditorCodeExecutionViewResultBlockFileType = "pdf"
)

// The properties Content, FileType, Type are required.
type BetaTextEditorCodeExecutionViewResultBlockParam struct {
	Content string `json:"content" api:"required"`
	// Any of "text", "image", "pdf".
	FileType   BetaTextEditorCodeExecutionViewResultBlockParamFileType `json:"file_type,omitzero" api:"required"`
	NumLines   param.Opt[int64]                                        `json:"num_lines,omitzero"`
	StartLine  param.Opt[int64]                                        `json:"start_line,omitzero"`
	TotalLines param.Opt[int64]                                        `json:"total_lines,omitzero"`
	// This field can be elided, and will marshal its zero value as
	// "text_editor_code_execution_view_result".
	Type constant.TextEditorCodeExecutionViewResult `json:"type" default:"text_editor_code_execution_view_result"`
	paramObj
}

func (r BetaTextEditorCodeExecutionViewResultBlockParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaTextEditorCodeExecutionViewResultBlockParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaTextEditorCodeExecutionViewResultBlockParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaTextEditorCodeExecutionViewResultBlockParamFileType string

const (
	BetaTextEditorCodeExecutionViewResultBlockParamFileTypeText  BetaTextEditorCodeExecutionViewResultBlockParamFileType = "text"
	BetaTextEditorCodeExecutionViewResultBlockParamFileTypeImage BetaTextEditorCodeExecutionViewResultBlockParamFileType = "image"
	BetaTextEditorCodeExecutionViewResultBlockParamFileTypePDF   BetaTextEditorCodeExecutionViewResultBlockParamFileType = "pdf"
)

type BetaThinkingBlock struct {
	// A value used to verify that this thinking block was generated by Claude when it
	// is passed back to the API.
	//
	// This is an opaque field and should not be interpreted or parsed. When passing
	// thinking blocks back to the API (required when using tools with extended
	// thinking), pass them back exactly as received, with this field intact.
	//
	// See
	// [extended thinking](https://platform.claude.com/docs/en/build-with-claude/extended-thinking)
	// for details.
	Signature string `json:"signature" api:"required"`
	// The text of Claude's thinking process for this block.
	Thinking string            `json:"thinking" api:"required"`
	Type     constant.Thinking `json:"type" default:"thinking"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Signature   respjson.Field
		Thinking    respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaThinkingBlock) RawJSON() string { return r.JSON.raw }
func (r *BetaThinkingBlock) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Controls for block binding: what happens when a thinking block this request
// sends back fails the conversation check. Every field is optional; an empty
// object means every default.
type BetaThinkingBlockBindingParam struct {
	// What happens when a thinking block in `messages` fails the conversation check:
	// it was created in a different conversation, or the messages before it have
	// changed since. `"error"` (the default) fails the request with a 400 error.
	// `"drop_block"` removes the failing blocks and the request proceeds; the model no
	// longer sees the dropped reasoning.
	//
	// Any of "error", "drop_block".
	PrefixMismatchBehavior BetaThinkingPrefixMismatchBehavior `json:"prefix_mismatch_behavior,omitzero"`
	paramObj
}

func (r BetaThinkingBlockBindingParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaThinkingBlockBindingParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaThinkingBlockBindingParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties Signature, Thinking, Type are required.
type BetaThinkingBlockParam struct {
	// The `signature` value of this thinking block, exactly as returned by the API in
	// a previous response. Used to verify that the block was generated by Claude.
	//
	// Thinking blocks must be passed back unmodified and in their original order; a
	// modified block results in a 400 `invalid_request_error`.
	Signature string `json:"signature" api:"required"`
	// The `thinking` text of this block as returned by the API.
	Thinking string `json:"thinking" api:"required"`
	// This field can be elided, and will marshal its zero value as "thinking".
	Type constant.Thinking `json:"type" default:"thinking"`
	paramObj
}

func (r BetaThinkingBlockParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaThinkingBlockParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaThinkingBlockParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The property Type is required.
type BetaThinkingConfigAdaptiveParam struct {
	// Controls how thinking content appears in the response. When set to `summarized`,
	// thinking is returned normally. When set to `omitted`, thinking content is
	// redacted but a signature is returned for multi-turn continuity. Defaults to
	// `summarized`.
	//
	// Any of "summarized", "omitted", "updates".
	Display BetaThinkingConfigAdaptiveDisplay `json:"display,omitzero"`
	// Controls for block binding: what happens when a thinking block this request
	// sends back fails the conversation check. Every field is optional; an empty
	// object means every default.
	BlockBinding BetaThinkingBlockBindingParam `json:"block_binding,omitzero"`
	// This field can be elided, and will marshal its zero value as "adaptive".
	Type constant.Adaptive `json:"type" default:"adaptive"`
	paramObj
}

func (r BetaThinkingConfigAdaptiveParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaThinkingConfigAdaptiveParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaThinkingConfigAdaptiveParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Controls how thinking content appears in the response. When set to `summarized`,
// thinking is returned normally. When set to `omitted`, thinking content is
// redacted but a signature is returned for multi-turn continuity. Defaults to
// `summarized`.
type BetaThinkingConfigAdaptiveDisplay string

const (
	BetaThinkingConfigAdaptiveDisplaySummarized BetaThinkingConfigAdaptiveDisplay = "summarized"
	BetaThinkingConfigAdaptiveDisplayOmitted    BetaThinkingConfigAdaptiveDisplay = "omitted"
	BetaThinkingConfigAdaptiveDisplayUpdates    BetaThinkingConfigAdaptiveDisplay = "updates"
)

func NewBetaThinkingConfigDisabledParam() BetaThinkingConfigDisabledParam {
	return BetaThinkingConfigDisabledParam{
		Type: "disabled",
	}
}

// This struct has a constant value, construct it with
// [NewBetaThinkingConfigDisabledParam].
type BetaThinkingConfigDisabledParam struct {
	Type constant.Disabled `json:"type" default:"disabled"`
	paramObj
}

func (r BetaThinkingConfigDisabledParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaThinkingConfigDisabledParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaThinkingConfigDisabledParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties BudgetTokens, Type are required.
type BetaThinkingConfigEnabledParam struct {
	// Determines how many tokens Claude can use for its internal reasoning process.
	// Larger budgets can enable more thorough analysis for complex problems, improving
	// response quality.
	//
	// Must be ≥1024 and less than `max_tokens`.
	//
	// See
	// [extended thinking](https://platform.claude.com/docs/en/build-with-claude/extended-thinking)
	// for details.
	BudgetTokens int64 `json:"budget_tokens" api:"required"`
	// Controls how thinking content appears in the response. When set to `summarized`,
	// thinking is returned normally. When set to `omitted`, thinking content is
	// redacted but a signature is returned for multi-turn continuity. Defaults to
	// `summarized`.
	//
	// Any of "summarized", "omitted", "updates".
	Display BetaThinkingConfigEnabledDisplay `json:"display,omitzero"`
	// Controls for block binding: what happens when a thinking block this request
	// sends back fails the conversation check. Every field is optional; an empty
	// object means every default.
	BlockBinding BetaThinkingBlockBindingParam `json:"block_binding,omitzero"`
	// This field can be elided, and will marshal its zero value as "enabled".
	Type constant.Enabled `json:"type" default:"enabled"`
	paramObj
}

func (r BetaThinkingConfigEnabledParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaThinkingConfigEnabledParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaThinkingConfigEnabledParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Controls how thinking content appears in the response. When set to `summarized`,
// thinking is returned normally. When set to `omitted`, thinking content is
// redacted but a signature is returned for multi-turn continuity. Defaults to
// `summarized`.
type BetaThinkingConfigEnabledDisplay string

const (
	BetaThinkingConfigEnabledDisplaySummarized BetaThinkingConfigEnabledDisplay = "summarized"
	BetaThinkingConfigEnabledDisplayOmitted    BetaThinkingConfigEnabledDisplay = "omitted"
	BetaThinkingConfigEnabledDisplayUpdates    BetaThinkingConfigEnabledDisplay = "updates"
)

func BetaThinkingConfigParamOfEnabled(budgetTokens int64) BetaThinkingConfigParamUnion {
	var enabled BetaThinkingConfigEnabledParam
	enabled.BudgetTokens = budgetTokens
	return BetaThinkingConfigParamUnion{OfEnabled: &enabled}
}

// Only one field can be non-zero.
//
// Use [param.IsOmitted] to confirm if a field is set.
type BetaThinkingConfigParamUnion struct {
	OfEnabled  *BetaThinkingConfigEnabledParam  `json:",omitzero,inline"`
	OfDisabled *BetaThinkingConfigDisabledParam `json:",omitzero,inline"`
	OfAdaptive *BetaThinkingConfigAdaptiveParam `json:",omitzero,inline"`
	paramUnion
}

func (u BetaThinkingConfigParamUnion) MarshalJSON() ([]byte, error) {
	return param.MarshalUnion(u, u.OfEnabled, u.OfDisabled, u.OfAdaptive)
}
func (u *BetaThinkingConfigParamUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, u)
}

func (u *BetaThinkingConfigParamUnion) asAny() any {
	if !param.IsOmitted(u.OfEnabled) {
		return u.OfEnabled
	} else if !param.IsOmitted(u.OfDisabled) {
		return u.OfDisabled
	} else if !param.IsOmitted(u.OfAdaptive) {
		return u.OfAdaptive
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaThinkingConfigParamUnion) GetBudgetTokens() *int64 {
	if vt := u.OfEnabled; vt != nil {
		return &vt.BudgetTokens
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaThinkingConfigParamUnion) GetType() *string {
	if vt := u.OfEnabled; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfDisabled; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfAdaptive; vt != nil {
		return (*string)(&vt.Type)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaThinkingConfigParamUnion) GetDisplay() *string {
	if vt := u.OfEnabled; vt != nil {
		return (*string)(&vt.Display)
	} else if vt := u.OfAdaptive; vt != nil {
		return (*string)(&vt.Display)
	}
	return nil
}

// Returns a pointer to the underlying variant's BlockBinding property, if present.
func (u BetaThinkingConfigParamUnion) GetBlockBinding() *BetaThinkingBlockBindingParam {
	if vt := u.OfEnabled; vt != nil {
		return &vt.BlockBinding
	} else if vt := u.OfAdaptive; vt != nil {
		return &vt.BlockBinding
	}
	return nil
}

func init() {
	apijson.RegisterUnion[BetaThinkingConfigParamUnion](
		"type",
		apijson.Discriminator[BetaThinkingConfigEnabledParam]("enabled"),
		apijson.Discriminator[BetaThinkingConfigDisabledParam]("disabled"),
		apijson.Discriminator[BetaThinkingConfigAdaptiveParam]("adaptive"),
	)
}

type BetaThinkingDelta struct {
	// Per-frame increment of a coarse, running estimate of the tokens this thinking
	// block has produced so far. Present whenever the
	// `thinking-token-count-2026-05-13` beta is set; `null` unless `thinking.display`
	// resolves to `"omitted"` and a count is due this frame. Sum the increments across
	// `thinking_delta` frames on this block for a progress indicator. Each increment
	// is a non-negative multiple of a fixed quantum and the cadence is rate-limited,
	// so this is a deliberately lossy display hint, not a billable count;
	// `usage.output_tokens` remains authoritative.
	EstimatedTokens int64 `json:"estimated_tokens" api:"required"`
	// The incremental `thinking` text for this content block. Concatenate the
	// `thinking` values of successive `thinking_delta` events to assemble the block's
	// full `thinking` value.
	Thinking string                 `json:"thinking" api:"required"`
	Type     constant.ThinkingDelta `json:"type" default:"thinking_delta"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		EstimatedTokens respjson.Field
		Thinking        respjson.Field
		Type            respjson.Field
		ExtraFields     map[string]respjson.Field
		raw             string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaThinkingDelta) RawJSON() string { return r.JSON.raw }
func (r *BetaThinkingDelta) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaThinkingDroppedInputTransformation struct {
	// Where the removed block was in your request, as `messages.{i}.content.{j}`: `i`
	// indexes the `messages` array you sent and `j` that message's `content` array —
	// the same form error messages use.
	Path string `json:"path" api:"required"`
	// Which binding check removed the block: `model_binding_mismatch` — it was created
	// by a model whose reasoning the requested model may not read;
	// `prefix_binding_mismatch` — the conversation before it differs from the
	// conversation it was created in (the rest of that turn's consecutive thinking
	// blocks are removed with it, each with this reason);
	// `organization_binding_mismatch` — it was created under a different organization
	// (an Anthropic organization, AWS account or Google Cloud project) and this
	// organization is not one of its additional organizations;
	// `end_user_binding_mismatch` — it was created for a different end user, or was
	// removed by the consumer-organization binding. A block that would fail several
	// checks reports one reason, in this order of precedence:
	// `organization_binding_mismatch`, `end_user_binding_mismatch`,
	// `model_binding_mismatch`, `prefix_binding_mismatch`.
	//
	// Any of "model_binding_mismatch", "prefix_binding_mismatch",
	// "organization_binding_mismatch", "end_user_binding_mismatch".
	Reason BetaThinkingDroppedInputTransformationReason `json:"reason" api:"required"`
	// Always `thinking_dropped` for this entry type.
	Type constant.ThinkingDropped `json:"type" default:"thinking_dropped"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Path        respjson.Field
		Reason      respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaThinkingDroppedInputTransformation) RawJSON() string { return r.JSON.raw }
func (r *BetaThinkingDroppedInputTransformation) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Which binding check removed the block: `model_binding_mismatch` — it was created
// by a model whose reasoning the requested model may not read;
// `prefix_binding_mismatch` — the conversation before it differs from the
// conversation it was created in (the rest of that turn's consecutive thinking
// blocks are removed with it, each with this reason);
// `organization_binding_mismatch` — it was created under a different organization
// (an Anthropic organization, AWS account or Google Cloud project) and this
// organization is not one of its additional organizations;
// `end_user_binding_mismatch` — it was created for a different end user, or was
// removed by the consumer-organization binding. A block that would fail several
// checks reports one reason, in this order of precedence:
// `organization_binding_mismatch`, `end_user_binding_mismatch`,
// `model_binding_mismatch`, `prefix_binding_mismatch`.
type BetaThinkingDroppedInputTransformationReason string

const (
	BetaThinkingDroppedInputTransformationReasonModelBindingMismatch        BetaThinkingDroppedInputTransformationReason = "model_binding_mismatch"
	BetaThinkingDroppedInputTransformationReasonPrefixBindingMismatch       BetaThinkingDroppedInputTransformationReason = "prefix_binding_mismatch"
	BetaThinkingDroppedInputTransformationReasonOrganizationBindingMismatch BetaThinkingDroppedInputTransformationReason = "organization_binding_mismatch"
	BetaThinkingDroppedInputTransformationReasonEndUserBindingMismatch      BetaThinkingDroppedInputTransformationReason = "end_user_binding_mismatch"
)

// What happens when a thinking block in `messages` fails the conversation check:
// it was created in a different conversation, or the messages before it have
// changed since. `"error"` (the default) fails the request with a 400 error.
// `"drop_block"` removes the failing blocks and the request proceeds; the model no
// longer sees the dropped reasoning.
type BetaThinkingPrefixMismatchBehavior string

const (
	BetaThinkingPrefixMismatchBehaviorError     BetaThinkingPrefixMismatchBehavior = "error"
	BetaThinkingPrefixMismatchBehaviorDropBlock BetaThinkingPrefixMismatchBehavior = "drop_block"
)

// The properties Type, Value are required.
type BetaThinkingTurnsParam struct {
	Value int64 `json:"value" api:"required"`
	// This field can be elided, and will marshal its zero value as "thinking_turns".
	Type constant.ThinkingTurns `json:"type" default:"thinking_turns"`
	paramObj
}

func (r BetaThinkingTurnsParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaThinkingTurnsParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaThinkingTurnsParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// User-configurable total token budget across contexts.
//
// The properties Total, Type are required.
type BetaTokenTaskBudgetParam struct {
	// Total token budget across all contexts in the session.
	Total int64 `json:"total" api:"required"`
	// Remaining tokens in the budget. Use this to track usage across contexts when
	// implementing compaction client-side. Defaults to total if not provided.
	Remaining param.Opt[int64] `json:"remaining,omitzero"`
	// The budget type. Currently only 'tokens' is supported.
	//
	// This field can be elided, and will marshal its zero value as "tokens".
	Type constant.Tokens `json:"type" default:"tokens"`
	paramObj
}

func (r BetaTokenTaskBudgetParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaTokenTaskBudgetParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaTokenTaskBudgetParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties InputSchema, Name are required.
type BetaToolParam struct {
	// [JSON schema](https://json-schema.org/draft/2020-12) for this tool's input.
	//
	// This defines the shape of the `input` that your tool accepts and that the model
	// will produce.
	InputSchema BetaToolInputSchemaParam `json:"input_schema,omitzero" api:"required"`
	// Name of the tool.
	//
	// This is how the tool will be called by the model and in `tool_use` blocks.
	Name string `json:"name" api:"required"`
	// Enable eager input streaming for this tool. When true, tool input parameters
	// will be streamed incrementally as they are generated, and types will be inferred
	// on-the-fly rather than buffering the full JSON output. When false, streaming is
	// disabled for this tool even if the fine-grained-tool-streaming beta is active.
	// When null (default), uses the default behavior based on beta headers.
	EagerInputStreaming param.Opt[bool] `json:"eager_input_streaming,omitzero"`
	// If true, tool will not be included in initial system prompt. Only loaded when
	// returned via tool_reference from tool search.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Description of what this tool does.
	//
	// Tool descriptions should be as detailed as possible. The more information that
	// the model has about what the tool is and how to use it, the better it will
	// perform. You can use natural language descriptions to reinforce important
	// aspects of the tool input JSON schema.
	Description param.Opt[string] `json:"description,omitzero"`
	// When true, guarantees schema validation on tool names and inputs
	Strict param.Opt[bool] `json:"strict,omitzero"`
	// Any of "custom".
	Type BetaToolType `json:"type,omitzero"`
	// Any of "direct", "code_execution_20250825", "code_execution_20260120",
	// "code_execution_20260521".
	AllowedCallers []string `json:"allowed_callers,omitzero"`
	// Create a cache control breakpoint at this content block.
	CacheControl  BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	InputExamples []map[string]any               `json:"input_examples,omitzero"`
	paramObj
}

func (r BetaToolParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaToolParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaToolParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// [JSON schema](https://json-schema.org/draft/2020-12) for this tool's input.
//
// This defines the shape of the `input` that your tool accepts and that the model
// will produce.
//
// The property Type is required.
type BetaToolInputSchemaParam struct {
	Properties any      `json:"properties,omitzero"`
	Required   []string `json:"required,omitzero"`
	// This field can be elided, and will marshal its zero value as "object".
	Type        constant.Object `json:"type" default:"object"`
	ExtraFields map[string]any  `json:"-"`
	paramObj
}

func (r BetaToolInputSchemaParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaToolInputSchemaParam
	return param.MarshalWithExtras(r, (*shadow)(&r), r.ExtraFields)
}
func (r *BetaToolInputSchemaParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaToolType string

const (
	BetaToolTypeCustom BetaToolType = "custom"
)

// The properties Name, Type are required.
type BetaToolBash20241022Param struct {
	// If true, tool will not be included in initial system prompt. Only loaded when
	// returned via tool_reference from tool search.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// When true, guarantees schema validation on tool names and inputs
	Strict param.Opt[bool] `json:"strict,omitzero"`
	// Any of "direct", "code_execution_20250825", "code_execution_20260120",
	// "code_execution_20260521".
	AllowedCallers []string `json:"allowed_callers,omitzero"`
	// Create a cache control breakpoint at this content block.
	CacheControl  BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	InputExamples []map[string]any               `json:"input_examples,omitzero"`
	// Name of the tool.
	//
	// This is how the tool will be called by the model and in `tool_use` blocks.
	//
	// This field can be elided, and will marshal its zero value as "bash".
	Name constant.Bash `json:"name" default:"bash"`
	// This field can be elided, and will marshal its zero value as "bash_20241022".
	Type constant.Bash20241022 `json:"type" default:"bash_20241022"`
	paramObj
}

func (r BetaToolBash20241022Param) MarshalJSON() (data []byte, err error) {
	type shadow BetaToolBash20241022Param
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaToolBash20241022Param) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties Name, Type are required.
type BetaToolBash20250124Param struct {
	// If true, tool will not be included in initial system prompt. Only loaded when
	// returned via tool_reference from tool search.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// When true, guarantees schema validation on tool names and inputs
	Strict param.Opt[bool] `json:"strict,omitzero"`
	// Any of "direct", "code_execution_20250825", "code_execution_20260120",
	// "code_execution_20260521".
	AllowedCallers []string `json:"allowed_callers,omitzero"`
	// Create a cache control breakpoint at this content block.
	CacheControl  BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	InputExamples []map[string]any               `json:"input_examples,omitzero"`
	// Name of the tool.
	//
	// This is how the tool will be called by the model and in `tool_use` blocks.
	//
	// This field can be elided, and will marshal its zero value as "bash".
	Name constant.Bash `json:"name" default:"bash"`
	// This field can be elided, and will marshal its zero value as "bash_20250124".
	Type constant.Bash20250124 `json:"type" default:"bash_20250124"`
	paramObj
}

func (r BetaToolBash20250124Param) MarshalJSON() (data []byte, err error) {
	type shadow BetaToolBash20250124Param
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaToolBash20250124Param) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Reference to a single MCP tool by its server and remote name — the same
// `server_name`/`name` pair `mcp_tool_use` carries.
//
// The properties Name, ServerName, Type are required.
type BetaToolChangeMCPToolReferenceParam struct {
	Name       string `json:"name" api:"required"`
	ServerName string `json:"server_name" api:"required"`
	// This field can be elided, and will marshal its zero value as
	// "mcp_tool_reference".
	Type constant.MCPToolReference `json:"type" default:"mcp_tool_reference"`
	paramObj
}

func (r BetaToolChangeMCPToolReferenceParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaToolChangeMCPToolReferenceParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaToolChangeMCPToolReferenceParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Reference to every tool in the named MCP server's toolset.
//
// The properties ServerName, Type are required.
type BetaToolChangeMCPToolsetReferenceParam struct {
	ServerName string `json:"server_name" api:"required"`
	// This field can be elided, and will marshal its zero value as
	// "mcp_toolset_reference".
	Type constant.MCPToolsetReference `json:"type" default:"mcp_toolset_reference"`
	paramObj
}

func (r BetaToolChangeMCPToolsetReferenceParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaToolChangeMCPToolsetReferenceParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaToolChangeMCPToolsetReferenceParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Reference to a single tool the caller declared directly in `tools[]`. Does not
// accept the composed `{server}_{name}` form the server assigns to MCP-resolved
// tools — use `mcp_tool_reference` or `mcp_toolset_reference` for those.
//
// The properties Name, Type are required.
type BetaToolChangeToolReferenceParam struct {
	Name string `json:"name" api:"required"`
	// This field can be elided, and will marshal its zero value as "tool_reference".
	Type constant.ToolReference `json:"type" default:"tool_reference"`
	paramObj
}

func (r BetaToolChangeToolReferenceParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaToolChangeToolReferenceParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaToolChangeToolReferenceParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

func BetaToolChoiceParamOfTool(name string) BetaToolChoiceUnionParam {
	var tool BetaToolChoiceToolParam
	tool.Name = name
	return BetaToolChoiceUnionParam{OfTool: &tool}
}

// Only one field can be non-zero.
//
// Use [param.IsOmitted] to confirm if a field is set.
type BetaToolChoiceUnionParam struct {
	OfAuto *BetaToolChoiceAutoParam `json:",omitzero,inline"`
	OfAny  *BetaToolChoiceAnyParam  `json:",omitzero,inline"`
	OfTool *BetaToolChoiceToolParam `json:",omitzero,inline"`
	OfNone *BetaToolChoiceNoneParam `json:",omitzero,inline"`
	paramUnion
}

func (u BetaToolChoiceUnionParam) MarshalJSON() ([]byte, error) {
	return param.MarshalUnion(u, u.OfAuto, u.OfAny, u.OfTool, u.OfNone)
}
func (u *BetaToolChoiceUnionParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, u)
}

func (u *BetaToolChoiceUnionParam) asAny() any {
	if !param.IsOmitted(u.OfAuto) {
		return u.OfAuto
	} else if !param.IsOmitted(u.OfAny) {
		return u.OfAny
	} else if !param.IsOmitted(u.OfTool) {
		return u.OfTool
	} else if !param.IsOmitted(u.OfNone) {
		return u.OfNone
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaToolChoiceUnionParam) GetName() *string {
	if vt := u.OfTool; vt != nil {
		return &vt.Name
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaToolChoiceUnionParam) GetType() *string {
	if vt := u.OfAuto; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfAny; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfTool; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfNone; vt != nil {
		return (*string)(&vt.Type)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaToolChoiceUnionParam) GetDisableParallelToolUse() *bool {
	if vt := u.OfAuto; vt != nil && vt.DisableParallelToolUse.Valid() {
		return &vt.DisableParallelToolUse.Value
	} else if vt := u.OfAny; vt != nil && vt.DisableParallelToolUse.Valid() {
		return &vt.DisableParallelToolUse.Value
	} else if vt := u.OfTool; vt != nil && vt.DisableParallelToolUse.Valid() {
		return &vt.DisableParallelToolUse.Value
	}
	return nil
}

func init() {
	apijson.RegisterUnion[BetaToolChoiceUnionParam](
		"type",
		apijson.Discriminator[BetaToolChoiceAutoParam]("auto"),
		apijson.Discriminator[BetaToolChoiceAnyParam]("any"),
		apijson.Discriminator[BetaToolChoiceToolParam]("tool"),
		apijson.Discriminator[BetaToolChoiceNoneParam]("none"),
	)
}

// The model will use any available tools.
//
// The property Type is required.
type BetaToolChoiceAnyParam struct {
	// Whether to disable parallel tool use.
	//
	// Defaults to `false`. If set to `true`, the model will output exactly one tool
	// use.
	DisableParallelToolUse param.Opt[bool] `json:"disable_parallel_tool_use,omitzero"`
	// This field can be elided, and will marshal its zero value as "any".
	Type constant.Any `json:"type" default:"any"`
	paramObj
}

func (r BetaToolChoiceAnyParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaToolChoiceAnyParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaToolChoiceAnyParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The model will automatically decide whether to use tools.
//
// The property Type is required.
type BetaToolChoiceAutoParam struct {
	// Whether to disable parallel tool use.
	//
	// Defaults to `false`. If set to `true`, the model will output at most one tool
	// use.
	DisableParallelToolUse param.Opt[bool] `json:"disable_parallel_tool_use,omitzero"`
	// This field can be elided, and will marshal its zero value as "auto".
	Type constant.Auto `json:"type" default:"auto"`
	paramObj
}

func (r BetaToolChoiceAutoParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaToolChoiceAutoParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaToolChoiceAutoParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

func NewBetaToolChoiceNoneParam() BetaToolChoiceNoneParam {
	return BetaToolChoiceNoneParam{
		Type: "none",
	}
}

// The model will not be allowed to use tools.
//
// This struct has a constant value, construct it with
// [NewBetaToolChoiceNoneParam].
type BetaToolChoiceNoneParam struct {
	Type constant.None `json:"type" default:"none"`
	paramObj
}

func (r BetaToolChoiceNoneParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaToolChoiceNoneParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaToolChoiceNoneParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The model will use the specified tool with `tool_choice.name`.
//
// The properties Name, Type are required.
type BetaToolChoiceToolParam struct {
	// The name of the tool to use.
	Name string `json:"name" api:"required"`
	// Whether to disable parallel tool use.
	//
	// Defaults to `false`. If set to `true`, the model will output exactly one tool
	// use.
	DisableParallelToolUse param.Opt[bool] `json:"disable_parallel_tool_use,omitzero"`
	// This field can be elided, and will marshal its zero value as "tool".
	Type constant.Tool `json:"type" default:"tool"`
	paramObj
}

func (r BetaToolChoiceToolParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaToolChoiceToolParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaToolChoiceToolParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties DisplayHeightPx, DisplayWidthPx, Name, Type are required.
type BetaToolComputerUse20241022Param struct {
	// The height of the display in pixels.
	DisplayHeightPx int64 `json:"display_height_px" api:"required"`
	// The width of the display in pixels.
	DisplayWidthPx int64 `json:"display_width_px" api:"required"`
	// The X11 display number (e.g. 0, 1) for the display.
	DisplayNumber param.Opt[int64] `json:"display_number,omitzero"`
	// If true, tool will not be included in initial system prompt. Only loaded when
	// returned via tool_reference from tool search.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// When true, guarantees schema validation on tool names and inputs
	Strict param.Opt[bool] `json:"strict,omitzero"`
	// Any of "direct", "code_execution_20250825", "code_execution_20260120",
	// "code_execution_20260521".
	AllowedCallers []string `json:"allowed_callers,omitzero"`
	// Create a cache control breakpoint at this content block.
	CacheControl  BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	InputExamples []map[string]any               `json:"input_examples,omitzero"`
	// Name of the tool.
	//
	// This is how the tool will be called by the model and in `tool_use` blocks.
	//
	// This field can be elided, and will marshal its zero value as "computer".
	Name constant.Computer `json:"name" default:"computer"`
	// This field can be elided, and will marshal its zero value as
	// "computer_20241022".
	Type constant.Computer20241022 `json:"type" default:"computer_20241022"`
	paramObj
}

func (r BetaToolComputerUse20241022Param) MarshalJSON() (data []byte, err error) {
	type shadow BetaToolComputerUse20241022Param
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaToolComputerUse20241022Param) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties DisplayHeightPx, DisplayWidthPx, Name, Type are required.
type BetaToolComputerUse20250124Param struct {
	// The height of the display in pixels.
	DisplayHeightPx int64 `json:"display_height_px" api:"required"`
	// The width of the display in pixels.
	DisplayWidthPx int64 `json:"display_width_px" api:"required"`
	// The X11 display number (e.g. 0, 1) for the display.
	DisplayNumber param.Opt[int64] `json:"display_number,omitzero"`
	// If true, tool will not be included in initial system prompt. Only loaded when
	// returned via tool_reference from tool search.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// When true, guarantees schema validation on tool names and inputs
	Strict param.Opt[bool] `json:"strict,omitzero"`
	// Any of "direct", "code_execution_20250825", "code_execution_20260120",
	// "code_execution_20260521".
	AllowedCallers []string `json:"allowed_callers,omitzero"`
	// Create a cache control breakpoint at this content block.
	CacheControl  BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	InputExamples []map[string]any               `json:"input_examples,omitzero"`
	// Name of the tool.
	//
	// This is how the tool will be called by the model and in `tool_use` blocks.
	//
	// This field can be elided, and will marshal its zero value as "computer".
	Name constant.Computer `json:"name" default:"computer"`
	// This field can be elided, and will marshal its zero value as
	// "computer_20250124".
	Type constant.Computer20250124 `json:"type" default:"computer_20250124"`
	paramObj
}

func (r BetaToolComputerUse20250124Param) MarshalJSON() (data []byte, err error) {
	type shadow BetaToolComputerUse20250124Param
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaToolComputerUse20250124Param) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties DisplayHeightPx, DisplayWidthPx, Name, Type are required.
type BetaToolComputerUse20251124Param struct {
	// The height of the display in pixels.
	DisplayHeightPx int64 `json:"display_height_px" api:"required"`
	// The width of the display in pixels.
	DisplayWidthPx int64 `json:"display_width_px" api:"required"`
	// The X11 display number (e.g. 0, 1) for the display.
	DisplayNumber param.Opt[int64] `json:"display_number,omitzero"`
	// If true, tool will not be included in initial system prompt. Only loaded when
	// returned via tool_reference from tool search.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// Whether to enable an action to take a zoomed-in screenshot of the screen.
	EnableZoom param.Opt[bool] `json:"enable_zoom,omitzero"`
	// When true, guarantees schema validation on tool names and inputs
	Strict param.Opt[bool] `json:"strict,omitzero"`
	// Any of "direct", "code_execution_20250825", "code_execution_20260120",
	// "code_execution_20260521".
	AllowedCallers []string `json:"allowed_callers,omitzero"`
	// Create a cache control breakpoint at this content block.
	CacheControl  BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	InputExamples []map[string]any               `json:"input_examples,omitzero"`
	// Name of the tool.
	//
	// This is how the tool will be called by the model and in `tool_use` blocks.
	//
	// This field can be elided, and will marshal its zero value as "computer".
	Name constant.Computer `json:"name" default:"computer"`
	// This field can be elided, and will marshal its zero value as
	// "computer_20251124".
	Type constant.Computer20251124 `json:"type" default:"computer_20251124"`
	paramObj
}

func (r BetaToolComputerUse20251124Param) MarshalJSON() (data []byte, err error) {
	type shadow BetaToolComputerUse20251124Param
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaToolComputerUse20251124Param) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaToolReferenceBlock struct {
	ToolName string                 `json:"tool_name" api:"required"`
	Type     constant.ToolReference `json:"type" default:"tool_reference"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ToolName    respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaToolReferenceBlock) RawJSON() string { return r.JSON.raw }
func (r *BetaToolReferenceBlock) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Tool reference block that can be included in tool_result content.
//
// The properties ToolName, Type are required.
type BetaToolReferenceBlockParam struct {
	ToolName string `json:"tool_name" api:"required"`
	// Create a cache control breakpoint at this content block.
	CacheControl BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	// This field can be elided, and will marshal its zero value as "tool_reference".
	Type constant.ToolReference `json:"type" default:"tool_reference"`
	paramObj
}

func (r BetaToolReferenceBlockParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaToolReferenceBlockParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaToolReferenceBlockParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties ToolUseID, Type are required.
type BetaToolResultBlockParam struct {
	ToolUseID string `json:"tool_use_id" api:"required"`
	// For a toolset member tool_result, the toolset family of the paired tool_use.
	ToolsetName param.Opt[string] `json:"toolset_name,omitzero"`
	IsError     param.Opt[bool]   `json:"is_error,omitzero"`
	// Create a cache control breakpoint at this content block.
	CacheControl BetaCacheControlEphemeralParam         `json:"cache_control,omitzero"`
	Content      []BetaToolResultBlockParamContentUnion `json:"content,omitzero"`
	// This field can be elided, and will marshal its zero value as "tool_result".
	Type constant.ToolResult `json:"type" default:"tool_result"`
	paramObj
}

func (r BetaToolResultBlockParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaToolResultBlockParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaToolResultBlockParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

func NewBetaToolResultTextBlockParam(toolUseID string, text string, isError bool) BetaToolResultBlockParam {
	var p BetaToolResultBlockParam
	p.ToolUseID = toolUseID
	p.IsError = param.Opt[bool]{Value: isError}
	p.Content = []BetaToolResultBlockParamContentUnion{
		{OfText: &BetaTextBlockParam{Text: text}},
	}
	return p
}

// Only one field can be non-zero.
//
// Use [param.IsOmitted] to confirm if a field is set.
type BetaToolResultBlockParamContentUnion struct {
	OfText          *BetaTextBlockParam            `json:",omitzero,inline"`
	OfImage         *BetaImageBlockParam           `json:",omitzero,inline"`
	OfSearchResult  *BetaSearchResultBlockParam    `json:",omitzero,inline"`
	OfDocument      *BetaRequestDocumentBlockParam `json:",omitzero,inline"`
	OfToolReference *BetaToolReferenceBlockParam   `json:",omitzero,inline"`
	OfBrowserState  *BetaBrowserStateBlockParam    `json:",omitzero,inline"`
	paramUnion
}

func (u BetaToolResultBlockParamContentUnion) MarshalJSON() ([]byte, error) {
	return param.MarshalUnion(u, u.OfText,
		u.OfImage,
		u.OfSearchResult,
		u.OfDocument,
		u.OfToolReference,
		u.OfBrowserState)
}
func (u *BetaToolResultBlockParamContentUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, u)
}

func (u *BetaToolResultBlockParamContentUnion) asAny() any {
	if !param.IsOmitted(u.OfText) {
		return u.OfText
	} else if !param.IsOmitted(u.OfImage) {
		return u.OfImage
	} else if !param.IsOmitted(u.OfSearchResult) {
		return u.OfSearchResult
	} else if !param.IsOmitted(u.OfDocument) {
		return u.OfDocument
	} else if !param.IsOmitted(u.OfToolReference) {
		return u.OfToolReference
	} else if !param.IsOmitted(u.OfBrowserState) {
		return u.OfBrowserState
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaToolResultBlockParamContentUnion) GetText() *string {
	if vt := u.OfText; vt != nil {
		return &vt.Text
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaToolResultBlockParamContentUnion) GetTransformations() *BetaImageTransformationsParam {
	if vt := u.OfImage; vt != nil {
		return &vt.Transformations
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaToolResultBlockParamContentUnion) GetContent() []BetaTextBlockParam {
	if vt := u.OfSearchResult; vt != nil {
		return vt.Content
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaToolResultBlockParamContentUnion) GetContext() *string {
	if vt := u.OfDocument; vt != nil && vt.Context.Valid() {
		return &vt.Context.Value
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaToolResultBlockParamContentUnion) GetToolName() *string {
	if vt := u.OfToolReference; vt != nil {
		return &vt.ToolName
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaToolResultBlockParamContentUnion) GetTabs() []BetaBrowserStateTabEntryParam {
	if vt := u.OfBrowserState; vt != nil {
		return vt.Tabs
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaToolResultBlockParamContentUnion) GetStateChanges() []BetaBrowserStateChangeUnionParam {
	if vt := u.OfBrowserState; vt != nil {
		return vt.StateChanges
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaToolResultBlockParamContentUnion) GetType() *string {
	if vt := u.OfText; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfImage; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfSearchResult; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfDocument; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfToolReference; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfBrowserState; vt != nil {
		return (*string)(&vt.Type)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaToolResultBlockParamContentUnion) GetTitle() *string {
	if vt := u.OfSearchResult; vt != nil {
		return (*string)(&vt.Title)
	} else if vt := u.OfDocument; vt != nil && vt.Title.Valid() {
		return &vt.Title.Value
	}
	return nil
}

// Returns a pointer to the underlying variant's CacheControl property, if present.
func (u BetaToolResultBlockParamContentUnion) GetCacheControl() *BetaCacheControlEphemeralParam {
	if vt := u.OfText; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfImage; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfSearchResult; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfDocument; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfToolReference; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfBrowserState; vt != nil {
		return &vt.CacheControl
	}
	return nil
}

// Returns a subunion which exports methods to access subproperties
//
// Or use AsAny() to get the underlying value
func (u BetaToolResultBlockParamContentUnion) GetCitations() (res betaToolResultBlockParamContentUnionCitations) {
	if vt := u.OfText; vt != nil {
		res.any = &vt.Citations
	} else if vt := u.OfSearchResult; vt != nil {
		res.any = &vt.Citations
	} else if vt := u.OfDocument; vt != nil {
		res.any = &vt.Citations
	}
	return
}

// Can have the runtime types [*[]BetaTextCitationParamUnion],
// [*BetaCitationsConfigParam]
type betaToolResultBlockParamContentUnionCitations struct{ any }

// Use the following switch statement to get the type of the union:
//
//	switch u.AsAny().(type) {
//	case *[]anthropic.BetaTextCitationParamUnion:
//	case *anthropic.BetaCitationsConfigParam:
//	default:
//	    fmt.Errorf("not present")
//	}
func (u betaToolResultBlockParamContentUnionCitations) AsAny() any { return u.any }

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolResultBlockParamContentUnionCitations) GetEnabled() *bool {
	switch vt := u.any.(type) {
	case *BetaCitationsConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	}
	return nil
}

// Returns a subunion which exports methods to access subproperties
//
// Or use AsAny() to get the underlying value
func (u BetaToolResultBlockParamContentUnion) GetSource() (res betaToolResultBlockParamContentUnionSource) {
	if vt := u.OfImage; vt != nil {
		res.any = vt.Source.asAny()
	} else if vt := u.OfSearchResult; vt != nil {
		res.any = &vt.Source
	} else if vt := u.OfDocument; vt != nil {
		res.any = vt.Source.asAny()
	}
	return
}

// Can have the runtime types [*BetaBase64ImageSourceParam],
// [*BetaURLImageSourceParam], [*BetaFileImageSourceParam], [*string],
// [*BetaBase64PDFSourceParam], [*BetaPlainTextSourceParam],
// [*BetaContentBlockSourceParam], [*BetaURLPDFSourceParam],
// [*BetaFileDocumentSourceParam]
type betaToolResultBlockParamContentUnionSource struct{ any }

// Use the following switch statement to get the type of the union:
//
//	switch u.AsAny().(type) {
//	case *anthropic.BetaBase64ImageSourceParam:
//	case *anthropic.BetaURLImageSourceParam:
//	case *anthropic.BetaFileImageSourceParam:
//	case *string:
//	case *anthropic.BetaBase64PDFSourceParam:
//	case *anthropic.BetaPlainTextSourceParam:
//	case *anthropic.BetaContentBlockSourceParam:
//	case *anthropic.BetaURLPDFSourceParam:
//	case *anthropic.BetaFileDocumentSourceParam:
//	default:
//	    fmt.Errorf("not present")
//	}
func (u betaToolResultBlockParamContentUnionSource) AsAny() any { return u.any }

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolResultBlockParamContentUnionSource) GetContent() *BetaContentBlockSourceContentUnionParam {
	switch vt := u.any.(type) {
	case *BetaRequestDocumentBlockSourceUnionParam:
		return vt.GetContent()
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolResultBlockParamContentUnionSource) GetData() *string {
	switch vt := u.any.(type) {
	case *BetaImageBlockParamSourceUnion:
		return vt.GetData()
	case *BetaRequestDocumentBlockSourceUnionParam:
		return vt.GetData()
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolResultBlockParamContentUnionSource) GetMediaType() *string {
	switch vt := u.any.(type) {
	case *BetaImageBlockParamSourceUnion:
		return vt.GetMediaType()
	case *BetaRequestDocumentBlockSourceUnionParam:
		return vt.GetMediaType()
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolResultBlockParamContentUnionSource) GetType() *string {
	switch vt := u.any.(type) {
	case *BetaImageBlockParamSourceUnion:
		return vt.GetType()
	case *BetaRequestDocumentBlockSourceUnionParam:
		return vt.GetType()
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolResultBlockParamContentUnionSource) GetURL() *string {
	switch vt := u.any.(type) {
	case *BetaImageBlockParamSourceUnion:
		return vt.GetURL()
	case *BetaRequestDocumentBlockSourceUnionParam:
		return vt.GetURL()
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolResultBlockParamContentUnionSource) GetFileID() *string {
	switch vt := u.any.(type) {
	case *BetaImageBlockParamSourceUnion:
		return vt.GetFileID()
	case *BetaRequestDocumentBlockSourceUnionParam:
		return vt.GetFileID()
	}
	return nil
}

func init() {
	apijson.RegisterUnion[BetaToolResultBlockParamContentUnion](
		"type",
		apijson.Discriminator[BetaTextBlockParam]("text"),
		apijson.Discriminator[BetaImageBlockParam]("image"),
		apijson.Discriminator[BetaSearchResultBlockParam]("search_result"),
		apijson.Discriminator[BetaRequestDocumentBlockParam]("document"),
		apijson.Discriminator[BetaToolReferenceBlockParam]("tool_reference"),
		apijson.Discriminator[BetaBrowserStateBlockParam]("browser_state"),
	)
}

// The properties Name, Type are required.
type BetaToolSearchToolBm25_20251119Param struct {
	// Any of "tool_search_tool_bm25_20251119", "tool_search_tool_bm25".
	Type BetaToolSearchToolBm25_20251119Type `json:"type,omitzero" api:"required"`
	// If true, tool will not be included in initial system prompt. Only loaded when
	// returned via tool_reference from tool search.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// When true, guarantees schema validation on tool names and inputs
	Strict param.Opt[bool] `json:"strict,omitzero"`
	// Any of "direct", "code_execution_20250825", "code_execution_20260120",
	// "code_execution_20260521".
	AllowedCallers []string `json:"allowed_callers,omitzero"`
	// Create a cache control breakpoint at this content block.
	CacheControl  BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	InputExamples []map[string]any               `json:"input_examples,omitzero"`
	// Name of the tool.
	//
	// This is how the tool will be called by the model and in `tool_use` blocks.
	//
	// This field can be elided, and will marshal its zero value as
	// "tool_search_tool_bm25".
	Name constant.ToolSearchToolBm25 `json:"name" default:"tool_search_tool_bm25"`
	paramObj
}

func (r BetaToolSearchToolBm25_20251119Param) MarshalJSON() (data []byte, err error) {
	type shadow BetaToolSearchToolBm25_20251119Param
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaToolSearchToolBm25_20251119Param) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaToolSearchToolBm25_20251119Type string

const (
	BetaToolSearchToolBm25_20251119TypeToolSearchToolBm25_20251119 BetaToolSearchToolBm25_20251119Type = "tool_search_tool_bm25_20251119"
	BetaToolSearchToolBm25_20251119TypeToolSearchToolBm25          BetaToolSearchToolBm25_20251119Type = "tool_search_tool_bm25"
)

// The properties Name, Type are required.
type BetaToolSearchToolRegex20251119Param struct {
	// Any of "tool_search_tool_regex_20251119", "tool_search_tool_regex".
	Type BetaToolSearchToolRegex20251119Type `json:"type,omitzero" api:"required"`
	// If true, tool will not be included in initial system prompt. Only loaded when
	// returned via tool_reference from tool search.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// When true, guarantees schema validation on tool names and inputs
	Strict param.Opt[bool] `json:"strict,omitzero"`
	// Any of "direct", "code_execution_20250825", "code_execution_20260120",
	// "code_execution_20260521".
	AllowedCallers []string `json:"allowed_callers,omitzero"`
	// Create a cache control breakpoint at this content block.
	CacheControl BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	// Name of the tool.
	//
	// This is how the tool will be called by the model and in `tool_use` blocks.
	//
	// This field can be elided, and will marshal its zero value as
	// "tool_search_tool_regex".
	Name constant.ToolSearchToolRegex `json:"name" default:"tool_search_tool_regex"`
	paramObj
}

func (r BetaToolSearchToolRegex20251119Param) MarshalJSON() (data []byte, err error) {
	type shadow BetaToolSearchToolRegex20251119Param
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaToolSearchToolRegex20251119Param) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaToolSearchToolRegex20251119Type string

const (
	BetaToolSearchToolRegex20251119TypeToolSearchToolRegex20251119 BetaToolSearchToolRegex20251119Type = "tool_search_tool_regex_20251119"
	BetaToolSearchToolRegex20251119TypeToolSearchToolRegex         BetaToolSearchToolRegex20251119Type = "tool_search_tool_regex"
)

type BetaToolSearchToolResultBlock struct {
	Content   BetaToolSearchToolResultBlockContentUnion `json:"content" api:"required"`
	ToolUseID string                                    `json:"tool_use_id" api:"required"`
	Type      constant.ToolSearchToolResult             `json:"type" default:"tool_search_tool_result"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Content     respjson.Field
		ToolUseID   respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaToolSearchToolResultBlock) RawJSON() string { return r.JSON.raw }
func (r *BetaToolSearchToolResultBlock) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// BetaToolSearchToolResultBlockContentUnion contains all possible properties and
// values from [BetaToolSearchToolResultError],
// [BetaToolSearchToolSearchResultBlock].
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
type BetaToolSearchToolResultBlockContentUnion struct {
	// This field is from variant [BetaToolSearchToolResultError].
	ErrorCode BetaToolSearchToolResultErrorErrorCode `json:"error_code"`
	// This field is from variant [BetaToolSearchToolResultError].
	ErrorMessage string `json:"error_message"`
	Type         string `json:"type"`
	// This field is from variant [BetaToolSearchToolSearchResultBlock].
	ToolReferences []BetaToolReferenceBlock `json:"tool_references"`
	JSON           struct {
		ErrorCode      respjson.Field
		ErrorMessage   respjson.Field
		Type           respjson.Field
		ToolReferences respjson.Field
		raw            string
	} `json:"-"`
}

func (u BetaToolSearchToolResultBlockContentUnion) AsResponseToolSearchToolResultError() (v BetaToolSearchToolResultError) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaToolSearchToolResultBlockContentUnion) AsResponseToolSearchToolSearchResultBlock() (v BetaToolSearchToolSearchResultBlock) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u BetaToolSearchToolResultBlockContentUnion) RawJSON() string { return u.JSON.raw }

func (r *BetaToolSearchToolResultBlockContentUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties Content, ToolUseID, Type are required.
type BetaToolSearchToolResultBlockParam struct {
	Content   BetaToolSearchToolResultBlockParamContentUnion `json:"content,omitzero" api:"required"`
	ToolUseID string                                         `json:"tool_use_id" api:"required"`
	// Create a cache control breakpoint at this content block.
	CacheControl BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	// This field can be elided, and will marshal its zero value as
	// "tool_search_tool_result".
	Type constant.ToolSearchToolResult `json:"type" default:"tool_search_tool_result"`
	paramObj
}

func (r BetaToolSearchToolResultBlockParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaToolSearchToolResultBlockParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaToolSearchToolResultBlockParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Only one field can be non-zero.
//
// Use [param.IsOmitted] to confirm if a field is set.
type BetaToolSearchToolResultBlockParamContentUnion struct {
	OfRequestToolSearchToolResultError       *BetaToolSearchToolResultErrorParam       `json:",omitzero,inline"`
	OfRequestToolSearchToolSearchResultBlock *BetaToolSearchToolSearchResultBlockParam `json:",omitzero,inline"`
	paramUnion
}

func (u BetaToolSearchToolResultBlockParamContentUnion) MarshalJSON() ([]byte, error) {
	return param.MarshalUnion(u, u.OfRequestToolSearchToolResultError, u.OfRequestToolSearchToolSearchResultBlock)
}
func (u *BetaToolSearchToolResultBlockParamContentUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, u)
}

func (u *BetaToolSearchToolResultBlockParamContentUnion) asAny() any {
	if !param.IsOmitted(u.OfRequestToolSearchToolResultError) {
		return u.OfRequestToolSearchToolResultError
	} else if !param.IsOmitted(u.OfRequestToolSearchToolSearchResultBlock) {
		return u.OfRequestToolSearchToolSearchResultBlock
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaToolSearchToolResultBlockParamContentUnion) GetErrorCode() *string {
	if vt := u.OfRequestToolSearchToolResultError; vt != nil {
		return (*string)(&vt.ErrorCode)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaToolSearchToolResultBlockParamContentUnion) GetErrorMessage() *string {
	if vt := u.OfRequestToolSearchToolResultError; vt != nil && vt.ErrorMessage.Valid() {
		return &vt.ErrorMessage.Value
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaToolSearchToolResultBlockParamContentUnion) GetToolReferences() []BetaToolReferenceBlockParam {
	if vt := u.OfRequestToolSearchToolSearchResultBlock; vt != nil {
		return vt.ToolReferences
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaToolSearchToolResultBlockParamContentUnion) GetType() *string {
	if vt := u.OfRequestToolSearchToolResultError; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfRequestToolSearchToolSearchResultBlock; vt != nil {
		return (*string)(&vt.Type)
	}
	return nil
}

type BetaToolSearchToolResultError struct {
	// Any of "invalid_tool_input", "unavailable", "too_many_requests",
	// "execution_time_exceeded".
	ErrorCode    BetaToolSearchToolResultErrorErrorCode `json:"error_code" api:"required"`
	ErrorMessage string                                 `json:"error_message" api:"required"`
	Type         constant.ToolSearchToolResultError     `json:"type" default:"tool_search_tool_result_error"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ErrorCode    respjson.Field
		ErrorMessage respjson.Field
		Type         respjson.Field
		ExtraFields  map[string]respjson.Field
		raw          string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaToolSearchToolResultError) RawJSON() string { return r.JSON.raw }
func (r *BetaToolSearchToolResultError) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaToolSearchToolResultErrorErrorCode string

const (
	BetaToolSearchToolResultErrorErrorCodeInvalidToolInput      BetaToolSearchToolResultErrorErrorCode = "invalid_tool_input"
	BetaToolSearchToolResultErrorErrorCodeUnavailable           BetaToolSearchToolResultErrorErrorCode = "unavailable"
	BetaToolSearchToolResultErrorErrorCodeTooManyRequests       BetaToolSearchToolResultErrorErrorCode = "too_many_requests"
	BetaToolSearchToolResultErrorErrorCodeExecutionTimeExceeded BetaToolSearchToolResultErrorErrorCode = "execution_time_exceeded"
)

// The properties ErrorCode, Type are required.
type BetaToolSearchToolResultErrorParam struct {
	// Any of "invalid_tool_input", "unavailable", "too_many_requests",
	// "execution_time_exceeded".
	ErrorCode    BetaToolSearchToolResultErrorParamErrorCode `json:"error_code,omitzero" api:"required"`
	ErrorMessage param.Opt[string]                           `json:"error_message,omitzero"`
	// This field can be elided, and will marshal its zero value as
	// "tool_search_tool_result_error".
	Type constant.ToolSearchToolResultError `json:"type" default:"tool_search_tool_result_error"`
	paramObj
}

func (r BetaToolSearchToolResultErrorParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaToolSearchToolResultErrorParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaToolSearchToolResultErrorParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaToolSearchToolResultErrorParamErrorCode string

const (
	BetaToolSearchToolResultErrorParamErrorCodeInvalidToolInput      BetaToolSearchToolResultErrorParamErrorCode = "invalid_tool_input"
	BetaToolSearchToolResultErrorParamErrorCodeUnavailable           BetaToolSearchToolResultErrorParamErrorCode = "unavailable"
	BetaToolSearchToolResultErrorParamErrorCodeTooManyRequests       BetaToolSearchToolResultErrorParamErrorCode = "too_many_requests"
	BetaToolSearchToolResultErrorParamErrorCodeExecutionTimeExceeded BetaToolSearchToolResultErrorParamErrorCode = "execution_time_exceeded"
)

type BetaToolSearchToolSearchResultBlock struct {
	ToolReferences []BetaToolReferenceBlock            `json:"tool_references" api:"required"`
	Type           constant.ToolSearchToolSearchResult `json:"type" default:"tool_search_tool_search_result"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ToolReferences respjson.Field
		Type           respjson.Field
		ExtraFields    map[string]respjson.Field
		raw            string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaToolSearchToolSearchResultBlock) RawJSON() string { return r.JSON.raw }
func (r *BetaToolSearchToolSearchResultBlock) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties ToolReferences, Type are required.
type BetaToolSearchToolSearchResultBlockParam struct {
	ToolReferences []BetaToolReferenceBlockParam `json:"tool_references,omitzero" api:"required"`
	// This field can be elided, and will marshal its zero value as
	// "tool_search_tool_search_result".
	Type constant.ToolSearchToolSearchResult `json:"type" default:"tool_search_tool_search_result"`
	paramObj
}

func (r BetaToolSearchToolSearchResultBlockParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaToolSearchToolSearchResultBlockParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaToolSearchToolSearchResultBlockParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties Name, Type are required.
type BetaToolTextEditor20241022Param struct {
	// If true, tool will not be included in initial system prompt. Only loaded when
	// returned via tool_reference from tool search.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// When true, guarantees schema validation on tool names and inputs
	Strict param.Opt[bool] `json:"strict,omitzero"`
	// Any of "direct", "code_execution_20250825", "code_execution_20260120",
	// "code_execution_20260521".
	AllowedCallers []string `json:"allowed_callers,omitzero"`
	// Create a cache control breakpoint at this content block.
	CacheControl  BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	InputExamples []map[string]any               `json:"input_examples,omitzero"`
	// Name of the tool.
	//
	// This is how the tool will be called by the model and in `tool_use` blocks.
	//
	// This field can be elided, and will marshal its zero value as
	// "str_replace_editor".
	Name constant.StrReplaceEditor `json:"name" default:"str_replace_editor"`
	// This field can be elided, and will marshal its zero value as
	// "text_editor_20241022".
	Type constant.TextEditor20241022 `json:"type" default:"text_editor_20241022"`
	paramObj
}

func (r BetaToolTextEditor20241022Param) MarshalJSON() (data []byte, err error) {
	type shadow BetaToolTextEditor20241022Param
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaToolTextEditor20241022Param) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties Name, Type are required.
type BetaToolTextEditor20250124Param struct {
	// If true, tool will not be included in initial system prompt. Only loaded when
	// returned via tool_reference from tool search.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// When true, guarantees schema validation on tool names and inputs
	Strict param.Opt[bool] `json:"strict,omitzero"`
	// Any of "direct", "code_execution_20250825", "code_execution_20260120",
	// "code_execution_20260521".
	AllowedCallers []string `json:"allowed_callers,omitzero"`
	// Create a cache control breakpoint at this content block.
	CacheControl  BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	InputExamples []map[string]any               `json:"input_examples,omitzero"`
	// Name of the tool.
	//
	// This is how the tool will be called by the model and in `tool_use` blocks.
	//
	// This field can be elided, and will marshal its zero value as
	// "str_replace_editor".
	Name constant.StrReplaceEditor `json:"name" default:"str_replace_editor"`
	// This field can be elided, and will marshal its zero value as
	// "text_editor_20250124".
	Type constant.TextEditor20250124 `json:"type" default:"text_editor_20250124"`
	paramObj
}

func (r BetaToolTextEditor20250124Param) MarshalJSON() (data []byte, err error) {
	type shadow BetaToolTextEditor20250124Param
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaToolTextEditor20250124Param) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties Name, Type are required.
type BetaToolTextEditor20250429Param struct {
	// If true, tool will not be included in initial system prompt. Only loaded when
	// returned via tool_reference from tool search.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// When true, guarantees schema validation on tool names and inputs
	Strict param.Opt[bool] `json:"strict,omitzero"`
	// Any of "direct", "code_execution_20250825", "code_execution_20260120",
	// "code_execution_20260521".
	AllowedCallers []string `json:"allowed_callers,omitzero"`
	// Create a cache control breakpoint at this content block.
	CacheControl  BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	InputExamples []map[string]any               `json:"input_examples,omitzero"`
	// Name of the tool.
	//
	// This is how the tool will be called by the model and in `tool_use` blocks.
	//
	// This field can be elided, and will marshal its zero value as
	// "str_replace_based_edit_tool".
	Name constant.StrReplaceBasedEditTool `json:"name" default:"str_replace_based_edit_tool"`
	// This field can be elided, and will marshal its zero value as
	// "text_editor_20250429".
	Type constant.TextEditor20250429 `json:"type" default:"text_editor_20250429"`
	paramObj
}

func (r BetaToolTextEditor20250429Param) MarshalJSON() (data []byte, err error) {
	type shadow BetaToolTextEditor20250429Param
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaToolTextEditor20250429Param) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties Name, Type are required.
type BetaToolTextEditor20250728Param struct {
	// Maximum number of characters to display when viewing a file. If not specified,
	// defaults to displaying the full file.
	MaxCharacters param.Opt[int64] `json:"max_characters,omitzero"`
	// If true, tool will not be included in initial system prompt. Only loaded when
	// returned via tool_reference from tool search.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// When true, guarantees schema validation on tool names and inputs
	Strict param.Opt[bool] `json:"strict,omitzero"`
	// Any of "direct", "code_execution_20250825", "code_execution_20260120",
	// "code_execution_20260521".
	AllowedCallers []string `json:"allowed_callers,omitzero"`
	// Create a cache control breakpoint at this content block.
	CacheControl  BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	InputExamples []map[string]any               `json:"input_examples,omitzero"`
	// Name of the tool.
	//
	// This is how the tool will be called by the model and in `tool_use` blocks.
	//
	// This field can be elided, and will marshal its zero value as
	// "str_replace_based_edit_tool".
	Name constant.StrReplaceBasedEditTool `json:"name" default:"str_replace_based_edit_tool"`
	// This field can be elided, and will marshal its zero value as
	// "text_editor_20250728".
	Type constant.TextEditor20250728 `json:"type" default:"text_editor_20250728"`
	paramObj
}

func (r BetaToolTextEditor20250728Param) MarshalJSON() (data []byte, err error) {
	type shadow BetaToolTextEditor20250728Param
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaToolTextEditor20250728Param) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

func BetaToolUnionParamOfTool(inputSchema BetaToolInputSchemaParam, name string) BetaToolUnionParam {
	var variant BetaToolParam
	variant.InputSchema = inputSchema
	variant.Name = name
	return BetaToolUnionParam{OfTool: &variant}
}

func BetaToolUnionParamOfComputerUseTool20241022(displayHeightPx int64, displayWidthPx int64) BetaToolUnionParam {
	var variant BetaToolComputerUse20241022Param
	variant.DisplayHeightPx = displayHeightPx
	variant.DisplayWidthPx = displayWidthPx
	return BetaToolUnionParam{OfComputerUseTool20241022: &variant}
}

func BetaToolUnionParamOfComputerUseTool20250124(displayHeightPx int64, displayWidthPx int64) BetaToolUnionParam {
	var variant BetaToolComputerUse20250124Param
	variant.DisplayHeightPx = displayHeightPx
	variant.DisplayWidthPx = displayWidthPx
	return BetaToolUnionParam{OfComputerUseTool20250124: &variant}
}

func BetaToolUnionParamOfComputerUseTool20251124(displayHeightPx int64, displayWidthPx int64) BetaToolUnionParam {
	var variant BetaToolComputerUse20251124Param
	variant.DisplayHeightPx = displayHeightPx
	variant.DisplayWidthPx = displayWidthPx
	return BetaToolUnionParam{OfComputerUseTool20251124: &variant}
}

func BetaToolUnionParamOfAdvisorTool20260301(model Model) BetaToolUnionParam {
	var variant BetaAdvisorTool20260301Param
	variant.Model = model
	return BetaToolUnionParam{OfAdvisorTool20260301: &variant}
}

func BetaToolUnionParamOfToolSearchToolBm25_20251119(type_ BetaToolSearchToolBm25_20251119Type) BetaToolUnionParam {
	var variant BetaToolSearchToolBm25_20251119Param
	variant.Type = type_
	return BetaToolUnionParam{OfToolSearchToolBm25_20251119: &variant}
}

func BetaToolUnionParamOfToolSearchToolRegex20251119(type_ BetaToolSearchToolRegex20251119Type) BetaToolUnionParam {
	var variant BetaToolSearchToolRegex20251119Param
	variant.Type = type_
	return BetaToolUnionParam{OfToolSearchToolRegex20251119: &variant}
}

func BetaToolUnionParamOfMCPToolset(mcpServerName string) BetaToolUnionParam {
	var variant BetaMCPToolsetParam
	variant.MCPServerName = mcpServerName
	return BetaToolUnionParam{OfMCPToolset: &variant}
}

// Only one field can be non-zero.
//
// Use [param.IsOmitted] to confirm if a field is set.
type BetaToolUnionParam struct {
	OfTool                        *BetaToolParam                        `json:",omitzero,inline"`
	OfBashTool20241022            *BetaToolBash20241022Param            `json:",omitzero,inline"`
	OfBashTool20250124            *BetaToolBash20250124Param            `json:",omitzero,inline"`
	OfCodeExecutionTool20250522   *BetaCodeExecutionTool20250522Param   `json:",omitzero,inline"`
	OfCodeExecutionTool20250825   *BetaCodeExecutionTool20250825Param   `json:",omitzero,inline"`
	OfCodeExecutionTool20260120   *BetaCodeExecutionTool20260120Param   `json:",omitzero,inline"`
	OfCodeExecutionTool20260521   *BetaCodeExecutionTool20260521Param   `json:",omitzero,inline"`
	OfBrowserToolset20260801      *BetaBrowserToolset20260801Param      `json:",omitzero,inline"`
	OfComputerUseTool20241022     *BetaToolComputerUse20241022Param     `json:",omitzero,inline"`
	OfMemoryTool20250818          *BetaMemoryTool20250818Param          `json:",omitzero,inline"`
	OfComputerUseTool20250124     *BetaToolComputerUse20250124Param     `json:",omitzero,inline"`
	OfTextEditor20241022          *BetaToolTextEditor20241022Param      `json:",omitzero,inline"`
	OfComputerUseTool20251124     *BetaToolComputerUse20251124Param     `json:",omitzero,inline"`
	OfComputerToolset20260801     *BetaComputerToolset20260801Param     `json:",omitzero,inline"`
	OfTextEditor20250124          *BetaToolTextEditor20250124Param      `json:",omitzero,inline"`
	OfTextEditor20250429          *BetaToolTextEditor20250429Param      `json:",omitzero,inline"`
	OfTextEditor20250728          *BetaToolTextEditor20250728Param      `json:",omitzero,inline"`
	OfWebSearchTool20250305       *BetaWebSearchTool20250305Param       `json:",omitzero,inline"`
	OfWebFetchTool20250910        *BetaWebFetchTool20250910Param        `json:",omitzero,inline"`
	OfWebSearchTool20260209       *BetaWebSearchTool20260209Param       `json:",omitzero,inline"`
	OfWebFetchTool20260209        *BetaWebFetchTool20260209Param        `json:",omitzero,inline"`
	OfWebFetchTool20260309        *BetaWebFetchTool20260309Param        `json:",omitzero,inline"`
	OfWebSearchTool20260318       *BetaWebSearchTool20260318Param       `json:",omitzero,inline"`
	OfWebFetchTool20260318        *BetaWebFetchTool20260318Param        `json:",omitzero,inline"`
	OfAdvisorTool20260301         *BetaAdvisorTool20260301Param         `json:",omitzero,inline"`
	OfToolSearchToolBm25_20251119 *BetaToolSearchToolBm25_20251119Param `json:",omitzero,inline"`
	OfToolSearchToolRegex20251119 *BetaToolSearchToolRegex20251119Param `json:",omitzero,inline"`
	OfMCPToolset                  *BetaMCPToolsetParam                  `json:",omitzero,inline"`
	paramUnion
}

func (u BetaToolUnionParam) MarshalJSON() ([]byte, error) {
	return param.MarshalUnion(u, u.OfTool,
		u.OfBashTool20241022,
		u.OfBashTool20250124,
		u.OfCodeExecutionTool20250522,
		u.OfCodeExecutionTool20250825,
		u.OfCodeExecutionTool20260120,
		u.OfCodeExecutionTool20260521,
		u.OfBrowserToolset20260801,
		u.OfComputerUseTool20241022,
		u.OfMemoryTool20250818,
		u.OfComputerUseTool20250124,
		u.OfTextEditor20241022,
		u.OfComputerUseTool20251124,
		u.OfComputerToolset20260801,
		u.OfTextEditor20250124,
		u.OfTextEditor20250429,
		u.OfTextEditor20250728,
		u.OfWebSearchTool20250305,
		u.OfWebFetchTool20250910,
		u.OfWebSearchTool20260209,
		u.OfWebFetchTool20260209,
		u.OfWebFetchTool20260309,
		u.OfWebSearchTool20260318,
		u.OfWebFetchTool20260318,
		u.OfAdvisorTool20260301,
		u.OfToolSearchToolBm25_20251119,
		u.OfToolSearchToolRegex20251119,
		u.OfMCPToolset)
}
func (u *BetaToolUnionParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, u)
}

func (u *BetaToolUnionParam) asAny() any {
	if !param.IsOmitted(u.OfTool) {
		return u.OfTool
	} else if !param.IsOmitted(u.OfBashTool20241022) {
		return u.OfBashTool20241022
	} else if !param.IsOmitted(u.OfBashTool20250124) {
		return u.OfBashTool20250124
	} else if !param.IsOmitted(u.OfCodeExecutionTool20250522) {
		return u.OfCodeExecutionTool20250522
	} else if !param.IsOmitted(u.OfCodeExecutionTool20250825) {
		return u.OfCodeExecutionTool20250825
	} else if !param.IsOmitted(u.OfCodeExecutionTool20260120) {
		return u.OfCodeExecutionTool20260120
	} else if !param.IsOmitted(u.OfCodeExecutionTool20260521) {
		return u.OfCodeExecutionTool20260521
	} else if !param.IsOmitted(u.OfBrowserToolset20260801) {
		return u.OfBrowserToolset20260801
	} else if !param.IsOmitted(u.OfComputerUseTool20241022) {
		return u.OfComputerUseTool20241022
	} else if !param.IsOmitted(u.OfMemoryTool20250818) {
		return u.OfMemoryTool20250818
	} else if !param.IsOmitted(u.OfComputerUseTool20250124) {
		return u.OfComputerUseTool20250124
	} else if !param.IsOmitted(u.OfTextEditor20241022) {
		return u.OfTextEditor20241022
	} else if !param.IsOmitted(u.OfComputerUseTool20251124) {
		return u.OfComputerUseTool20251124
	} else if !param.IsOmitted(u.OfComputerToolset20260801) {
		return u.OfComputerToolset20260801
	} else if !param.IsOmitted(u.OfTextEditor20250124) {
		return u.OfTextEditor20250124
	} else if !param.IsOmitted(u.OfTextEditor20250429) {
		return u.OfTextEditor20250429
	} else if !param.IsOmitted(u.OfTextEditor20250728) {
		return u.OfTextEditor20250728
	} else if !param.IsOmitted(u.OfWebSearchTool20250305) {
		return u.OfWebSearchTool20250305
	} else if !param.IsOmitted(u.OfWebFetchTool20250910) {
		return u.OfWebFetchTool20250910
	} else if !param.IsOmitted(u.OfWebSearchTool20260209) {
		return u.OfWebSearchTool20260209
	} else if !param.IsOmitted(u.OfWebFetchTool20260209) {
		return u.OfWebFetchTool20260209
	} else if !param.IsOmitted(u.OfWebFetchTool20260309) {
		return u.OfWebFetchTool20260309
	} else if !param.IsOmitted(u.OfWebSearchTool20260318) {
		return u.OfWebSearchTool20260318
	} else if !param.IsOmitted(u.OfWebFetchTool20260318) {
		return u.OfWebFetchTool20260318
	} else if !param.IsOmitted(u.OfAdvisorTool20260301) {
		return u.OfAdvisorTool20260301
	} else if !param.IsOmitted(u.OfToolSearchToolBm25_20251119) {
		return u.OfToolSearchToolBm25_20251119
	} else if !param.IsOmitted(u.OfToolSearchToolRegex20251119) {
		return u.OfToolSearchToolRegex20251119
	} else if !param.IsOmitted(u.OfMCPToolset) {
		return u.OfMCPToolset
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaToolUnionParam) GetInputSchema() *BetaToolInputSchemaParam {
	if vt := u.OfTool; vt != nil {
		return &vt.InputSchema
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaToolUnionParam) GetDescription() *string {
	if vt := u.OfTool; vt != nil && vt.Description.Valid() {
		return &vt.Description.Value
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaToolUnionParam) GetEagerInputStreaming() *bool {
	if vt := u.OfTool; vt != nil && vt.EagerInputStreaming.Valid() {
		return &vt.EagerInputStreaming.Value
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaToolUnionParam) GetEnableZoom() *bool {
	if vt := u.OfComputerUseTool20251124; vt != nil && vt.EnableZoom.Valid() {
		return &vt.EnableZoom.Value
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaToolUnionParam) GetMaxCharacters() *int64 {
	if vt := u.OfTextEditor20250728; vt != nil && vt.MaxCharacters.Valid() {
		return &vt.MaxCharacters.Value
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaToolUnionParam) GetModel() *Model {
	if vt := u.OfAdvisorTool20260301; vt != nil {
		return &vt.Model
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaToolUnionParam) GetCaching() *BetaCacheControlEphemeralParam {
	if vt := u.OfAdvisorTool20260301; vt != nil {
		return &vt.Caching
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaToolUnionParam) GetMaxTokens() *int64 {
	if vt := u.OfAdvisorTool20260301; vt != nil && vt.MaxTokens.Valid() {
		return &vt.MaxTokens.Value
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaToolUnionParam) GetMCPServerName() *string {
	if vt := u.OfMCPToolset; vt != nil {
		return &vt.MCPServerName
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaToolUnionParam) GetDefaultConfig() *BetaMCPToolDefaultConfigParam {
	if vt := u.OfMCPToolset; vt != nil {
		return &vt.DefaultConfig
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaToolUnionParam) GetName() *string {
	if vt := u.OfTool; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfBashTool20241022; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfBashTool20250124; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfCodeExecutionTool20250522; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfCodeExecutionTool20250825; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfCodeExecutionTool20260120; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfCodeExecutionTool20260521; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfComputerUseTool20241022; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfMemoryTool20250818; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfComputerUseTool20250124; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfTextEditor20241022; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfComputerUseTool20251124; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfTextEditor20250124; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfTextEditor20250429; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfTextEditor20250728; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfWebSearchTool20250305; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfWebFetchTool20250910; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfWebSearchTool20260209; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfWebFetchTool20260209; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfWebFetchTool20260309; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfWebSearchTool20260318; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfWebFetchTool20260318; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfAdvisorTool20260301; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfToolSearchToolBm25_20251119; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfToolSearchToolRegex20251119; vt != nil {
		return (*string)(&vt.Name)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaToolUnionParam) GetDeferLoading() *bool {
	if vt := u.OfTool; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfBashTool20241022; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfBashTool20250124; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfCodeExecutionTool20250522; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfCodeExecutionTool20250825; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfCodeExecutionTool20260120; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfCodeExecutionTool20260521; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfComputerUseTool20241022; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfMemoryTool20250818; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfComputerUseTool20250124; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfTextEditor20241022; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfComputerUseTool20251124; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfTextEditor20250124; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfTextEditor20250429; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfTextEditor20250728; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfWebSearchTool20250305; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfWebFetchTool20250910; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfWebSearchTool20260209; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfWebFetchTool20260209; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfWebFetchTool20260309; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfWebSearchTool20260318; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfWebFetchTool20260318; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfAdvisorTool20260301; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfToolSearchToolBm25_20251119; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfToolSearchToolRegex20251119; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaToolUnionParam) GetStrict() *bool {
	if vt := u.OfTool; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfBashTool20241022; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfBashTool20250124; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfCodeExecutionTool20250522; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfCodeExecutionTool20250825; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfCodeExecutionTool20260120; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfCodeExecutionTool20260521; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfComputerUseTool20241022; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfMemoryTool20250818; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfComputerUseTool20250124; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfTextEditor20241022; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfComputerUseTool20251124; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfTextEditor20250124; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfTextEditor20250429; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfTextEditor20250728; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfWebSearchTool20250305; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfWebFetchTool20250910; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfWebSearchTool20260209; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfWebFetchTool20260209; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfWebFetchTool20260309; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfWebSearchTool20260318; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfWebFetchTool20260318; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfAdvisorTool20260301; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfToolSearchToolBm25_20251119; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfToolSearchToolRegex20251119; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaToolUnionParam) GetType() *string {
	if vt := u.OfTool; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfBashTool20241022; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfBashTool20250124; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfCodeExecutionTool20250522; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfCodeExecutionTool20250825; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfCodeExecutionTool20260120; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfCodeExecutionTool20260521; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfBrowserToolset20260801; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfComputerUseTool20241022; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfMemoryTool20250818; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfComputerUseTool20250124; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfTextEditor20241022; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfComputerUseTool20251124; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfComputerToolset20260801; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfTextEditor20250124; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfTextEditor20250429; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfTextEditor20250728; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfWebSearchTool20250305; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfWebFetchTool20250910; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfWebSearchTool20260209; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfWebFetchTool20260209; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfWebFetchTool20260309; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfWebSearchTool20260318; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfWebFetchTool20260318; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfAdvisorTool20260301; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfToolSearchToolBm25_20251119; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfToolSearchToolRegex20251119; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfMCPToolset; vt != nil {
		return (*string)(&vt.Type)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaToolUnionParam) GetDisplayHeightPx() *int64 {
	if vt := u.OfComputerUseTool20241022; vt != nil {
		return (*int64)(&vt.DisplayHeightPx)
	} else if vt := u.OfComputerUseTool20250124; vt != nil {
		return (*int64)(&vt.DisplayHeightPx)
	} else if vt := u.OfComputerUseTool20251124; vt != nil {
		return (*int64)(&vt.DisplayHeightPx)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaToolUnionParam) GetDisplayWidthPx() *int64 {
	if vt := u.OfComputerUseTool20241022; vt != nil {
		return (*int64)(&vt.DisplayWidthPx)
	} else if vt := u.OfComputerUseTool20250124; vt != nil {
		return (*int64)(&vt.DisplayWidthPx)
	} else if vt := u.OfComputerUseTool20251124; vt != nil {
		return (*int64)(&vt.DisplayWidthPx)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaToolUnionParam) GetDisplayNumber() *int64 {
	if vt := u.OfComputerUseTool20241022; vt != nil && vt.DisplayNumber.Valid() {
		return &vt.DisplayNumber.Value
	} else if vt := u.OfComputerUseTool20250124; vt != nil && vt.DisplayNumber.Valid() {
		return &vt.DisplayNumber.Value
	} else if vt := u.OfComputerUseTool20251124; vt != nil && vt.DisplayNumber.Valid() {
		return &vt.DisplayNumber.Value
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaToolUnionParam) GetMaxUses() *int64 {
	if vt := u.OfWebSearchTool20250305; vt != nil && vt.MaxUses.Valid() {
		return &vt.MaxUses.Value
	} else if vt := u.OfWebFetchTool20250910; vt != nil && vt.MaxUses.Valid() {
		return &vt.MaxUses.Value
	} else if vt := u.OfWebSearchTool20260209; vt != nil && vt.MaxUses.Valid() {
		return &vt.MaxUses.Value
	} else if vt := u.OfWebFetchTool20260209; vt != nil && vt.MaxUses.Valid() {
		return &vt.MaxUses.Value
	} else if vt := u.OfWebFetchTool20260309; vt != nil && vt.MaxUses.Valid() {
		return &vt.MaxUses.Value
	} else if vt := u.OfWebSearchTool20260318; vt != nil && vt.MaxUses.Valid() {
		return &vt.MaxUses.Value
	} else if vt := u.OfWebFetchTool20260318; vt != nil && vt.MaxUses.Valid() {
		return &vt.MaxUses.Value
	} else if vt := u.OfAdvisorTool20260301; vt != nil && vt.MaxUses.Valid() {
		return &vt.MaxUses.Value
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaToolUnionParam) GetMaxContentTokens() *int64 {
	if vt := u.OfWebFetchTool20250910; vt != nil && vt.MaxContentTokens.Valid() {
		return &vt.MaxContentTokens.Value
	} else if vt := u.OfWebFetchTool20260209; vt != nil && vt.MaxContentTokens.Valid() {
		return &vt.MaxContentTokens.Value
	} else if vt := u.OfWebFetchTool20260309; vt != nil && vt.MaxContentTokens.Valid() {
		return &vt.MaxContentTokens.Value
	} else if vt := u.OfWebFetchTool20260318; vt != nil && vt.MaxContentTokens.Valid() {
		return &vt.MaxContentTokens.Value
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaToolUnionParam) GetUseCache() *bool {
	if vt := u.OfWebFetchTool20260309; vt != nil && vt.UseCache.Valid() {
		return &vt.UseCache.Value
	} else if vt := u.OfWebFetchTool20260318; vt != nil && vt.UseCache.Valid() {
		return &vt.UseCache.Value
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaToolUnionParam) GetResponseInclusion() *string {
	if vt := u.OfWebSearchTool20260318; vt != nil {
		return (*string)(&vt.ResponseInclusion)
	} else if vt := u.OfWebFetchTool20260318; vt != nil {
		return (*string)(&vt.ResponseInclusion)
	}
	return nil
}

// Returns a pointer to the underlying variant's AllowedCallers property, if
// present.
func (u BetaToolUnionParam) GetAllowedCallers() []string {
	if vt := u.OfTool; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfBashTool20241022; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfBashTool20250124; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfCodeExecutionTool20250522; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfCodeExecutionTool20250825; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfCodeExecutionTool20260120; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfCodeExecutionTool20260521; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfComputerUseTool20241022; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfMemoryTool20250818; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfComputerUseTool20250124; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfTextEditor20241022; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfComputerUseTool20251124; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfTextEditor20250124; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfTextEditor20250429; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfTextEditor20250728; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfWebSearchTool20250305; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfWebFetchTool20250910; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfWebSearchTool20260209; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfWebFetchTool20260209; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfWebFetchTool20260309; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfWebSearchTool20260318; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfWebFetchTool20260318; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfAdvisorTool20260301; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfToolSearchToolBm25_20251119; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfToolSearchToolRegex20251119; vt != nil {
		return vt.AllowedCallers
	}
	return nil
}

// Returns a pointer to the underlying variant's CacheControl property, if present.
func (u BetaToolUnionParam) GetCacheControl() *BetaCacheControlEphemeralParam {
	if vt := u.OfTool; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfBashTool20241022; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfBashTool20250124; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfCodeExecutionTool20250522; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfCodeExecutionTool20250825; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfCodeExecutionTool20260120; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfCodeExecutionTool20260521; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfBrowserToolset20260801; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfComputerUseTool20241022; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfMemoryTool20250818; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfComputerUseTool20250124; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfTextEditor20241022; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfComputerUseTool20251124; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfComputerToolset20260801; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfTextEditor20250124; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfTextEditor20250429; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfTextEditor20250728; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfWebSearchTool20250305; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfWebFetchTool20250910; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfWebSearchTool20260209; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfWebFetchTool20260209; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfWebFetchTool20260309; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfWebSearchTool20260318; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfWebFetchTool20260318; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfAdvisorTool20260301; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfToolSearchToolBm25_20251119; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfToolSearchToolRegex20251119; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfMCPToolset; vt != nil {
		return &vt.CacheControl
	}
	return nil
}

// Returns a pointer to the underlying variant's InputExamples property, if
// present.
func (u BetaToolUnionParam) GetInputExamples() []map[string]any {
	if vt := u.OfTool; vt != nil {
		return vt.InputExamples
	} else if vt := u.OfBashTool20241022; vt != nil {
		return vt.InputExamples
	} else if vt := u.OfBashTool20250124; vt != nil {
		return vt.InputExamples
	} else if vt := u.OfComputerUseTool20241022; vt != nil {
		return vt.InputExamples
	} else if vt := u.OfMemoryTool20250818; vt != nil {
		return vt.InputExamples
	} else if vt := u.OfComputerUseTool20250124; vt != nil {
		return vt.InputExamples
	} else if vt := u.OfTextEditor20241022; vt != nil {
		return vt.InputExamples
	} else if vt := u.OfComputerUseTool20251124; vt != nil {
		return vt.InputExamples
	} else if vt := u.OfTextEditor20250124; vt != nil {
		return vt.InputExamples
	} else if vt := u.OfTextEditor20250429; vt != nil {
		return vt.InputExamples
	} else if vt := u.OfTextEditor20250728; vt != nil {
		return vt.InputExamples
	}
	return nil
}

// Returns a subunion which exports methods to access subproperties
//
// Or use AsAny() to get the underlying value
func (u BetaToolUnionParam) GetConfigs() (res betaToolUnionParamConfigs) {
	if vt := u.OfBrowserToolset20260801; vt != nil {
		res.any = &vt.Configs
	} else if vt := u.OfComputerToolset20260801; vt != nil {
		res.any = &vt.Configs
	} else if vt := u.OfMCPToolset; vt != nil {
		res.any = &vt.Configs
	}
	return
}

// Can have the runtime types [*BetaBrowserToolsetConfigsParam],
// [*BetaComputerToolsetConfigsParam], [\*map[string]BetaMCPToolConfigParam]
type betaToolUnionParamConfigs struct{ any }

// Use the following switch statement to get the type of the union:
//
//	switch u.AsAny().(type) {
//	case *anthropic.BetaBrowserToolsetConfigsParam:
//	case *anthropic.BetaComputerToolsetConfigsParam:
//	case *map[string]anthropic.BetaMCPToolConfigParam:
//	default:
//	    fmt.Errorf("not present")
//	}
func (u betaToolUnionParamConfigs) AsAny() any { return u.any }

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigs) GetCloseTab() *BetaBrowserCloseTabConfigParam {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		return &vt.CloseTab
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigs) GetFileUpload() *BetaBrowserFileUploadConfigParam {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		return &vt.FileUpload
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigs) GetFind() *BetaBrowserFindConfigParam {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		return &vt.Find
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigs) GetFormInput() *BetaBrowserFormInputConfigParam {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		return &vt.FormInput
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigs) GetGetPageText() *BetaBrowserGetPageTextConfigParam {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		return &vt.GetPageText
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigs) GetHover() *BetaBrowserHoverConfigParam {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		return &vt.Hover
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigs) GetJavascriptExec() *BetaBrowserJavascriptExecConfigParam {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		return &vt.JavascriptExec
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigs) GetListTabs() *BetaBrowserListTabsConfigParam {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		return &vt.ListTabs
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigs) GetNavigate() *BetaBrowserNavigateConfigParam {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		return &vt.Navigate
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigs) GetNewTab() *BetaBrowserNewTabConfigParam {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		return &vt.NewTab
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigs) GetReadConsole() *BetaBrowserReadConsoleConfigParam {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		return &vt.ReadConsole
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigs) GetReadNetwork() *BetaBrowserReadNetworkConfigParam {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		return &vt.ReadNetwork
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigs) GetReadPage() *BetaBrowserReadPageConfigParam {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		return &vt.ReadPage
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigs) GetScrollTo() *BetaBrowserScrollToConfigParam {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		return &vt.ScrollTo
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigs) GetSwitchTab() *BetaBrowserSwitchTabConfigParam {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		return &vt.SwitchTab
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigs) GetCursorPosition() *BetaComputerCursorPositionConfigParam {
	switch vt := u.any.(type) {
	case *BetaComputerToolsetConfigsParam:
		return &vt.CursorPosition
	}
	return nil
}

// Returns a subunion which exports methods to access subproperties
//
// Or use AsAny() to get the underlying value
func (u betaToolUnionParamConfigs) GetDoubleClick() (res betaToolUnionParamConfigsDoubleClick) {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		res.any = &vt.DoubleClick
	case *BetaComputerToolsetConfigsParam:
		res.any = &vt.DoubleClick
	}
	return res
}

// Can have the runtime types [*BetaBrowserDoubleClickConfigParam],
// [*BetaComputerDoubleClickConfigParam]
type betaToolUnionParamConfigsDoubleClick struct{ any }

// Use the following switch statement to get the type of the union:
//
//	switch u.AsAny().(type) {
//	case *anthropic.BetaBrowserDoubleClickConfigParam:
//	case *anthropic.BetaComputerDoubleClickConfigParam:
//	default:
//	    fmt.Errorf("not present")
//	}
func (u betaToolUnionParamConfigsDoubleClick) AsAny() any { return u.any }

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigsDoubleClick) GetDeferLoading() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserDoubleClickConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	case *BetaComputerDoubleClickConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigsDoubleClick) GetEnabled() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserDoubleClickConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	case *BetaComputerDoubleClickConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	}
	return nil
}

// Returns a subunion which exports methods to access subproperties
//
// Or use AsAny() to get the underlying value
func (u betaToolUnionParamConfigs) GetHoldKey() (res betaToolUnionParamConfigsHoldKey) {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		res.any = &vt.HoldKey
	case *BetaComputerToolsetConfigsParam:
		res.any = &vt.HoldKey
	}
	return res
}

// Can have the runtime types [*BetaBrowserHoldKeyConfigParam],
// [*BetaComputerHoldKeyConfigParam]
type betaToolUnionParamConfigsHoldKey struct{ any }

// Use the following switch statement to get the type of the union:
//
//	switch u.AsAny().(type) {
//	case *anthropic.BetaBrowserHoldKeyConfigParam:
//	case *anthropic.BetaComputerHoldKeyConfigParam:
//	default:
//	    fmt.Errorf("not present")
//	}
func (u betaToolUnionParamConfigsHoldKey) AsAny() any { return u.any }

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigsHoldKey) GetDeferLoading() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserHoldKeyConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	case *BetaComputerHoldKeyConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigsHoldKey) GetEnabled() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserHoldKeyConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	case *BetaComputerHoldKeyConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	}
	return nil
}

// Returns a subunion which exports methods to access subproperties
//
// Or use AsAny() to get the underlying value
func (u betaToolUnionParamConfigs) GetKey() (res betaToolUnionParamConfigsKey) {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		res.any = &vt.Key
	case *BetaComputerToolsetConfigsParam:
		res.any = &vt.Key
	}
	return res
}

// Can have the runtime types [*BetaBrowserKeyConfigParam],
// [*BetaComputerKeyConfigParam]
type betaToolUnionParamConfigsKey struct{ any }

// Use the following switch statement to get the type of the union:
//
//	switch u.AsAny().(type) {
//	case *anthropic.BetaBrowserKeyConfigParam:
//	case *anthropic.BetaComputerKeyConfigParam:
//	default:
//	    fmt.Errorf("not present")
//	}
func (u betaToolUnionParamConfigsKey) AsAny() any { return u.any }

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigsKey) GetDeferLoading() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserKeyConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	case *BetaComputerKeyConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigsKey) GetEnabled() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserKeyConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	case *BetaComputerKeyConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	}
	return nil
}

// Returns a subunion which exports methods to access subproperties
//
// Or use AsAny() to get the underlying value
func (u betaToolUnionParamConfigs) GetLeftClick() (res betaToolUnionParamConfigsLeftClick) {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		res.any = &vt.LeftClick
	case *BetaComputerToolsetConfigsParam:
		res.any = &vt.LeftClick
	}
	return res
}

// Can have the runtime types [*BetaBrowserLeftClickConfigParam],
// [*BetaComputerLeftClickConfigParam]
type betaToolUnionParamConfigsLeftClick struct{ any }

// Use the following switch statement to get the type of the union:
//
//	switch u.AsAny().(type) {
//	case *anthropic.BetaBrowserLeftClickConfigParam:
//	case *anthropic.BetaComputerLeftClickConfigParam:
//	default:
//	    fmt.Errorf("not present")
//	}
func (u betaToolUnionParamConfigsLeftClick) AsAny() any { return u.any }

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigsLeftClick) GetDeferLoading() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserLeftClickConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	case *BetaComputerLeftClickConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigsLeftClick) GetEnabled() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserLeftClickConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	case *BetaComputerLeftClickConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	}
	return nil
}

// Returns a subunion which exports methods to access subproperties
//
// Or use AsAny() to get the underlying value
func (u betaToolUnionParamConfigs) GetLeftClickDrag() (res betaToolUnionParamConfigsLeftClickDrag) {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		res.any = &vt.LeftClickDrag
	case *BetaComputerToolsetConfigsParam:
		res.any = &vt.LeftClickDrag
	}
	return res
}

// Can have the runtime types [*BetaBrowserLeftClickDragConfigParam],
// [*BetaComputerLeftClickDragConfigParam]
type betaToolUnionParamConfigsLeftClickDrag struct{ any }

// Use the following switch statement to get the type of the union:
//
//	switch u.AsAny().(type) {
//	case *anthropic.BetaBrowserLeftClickDragConfigParam:
//	case *anthropic.BetaComputerLeftClickDragConfigParam:
//	default:
//	    fmt.Errorf("not present")
//	}
func (u betaToolUnionParamConfigsLeftClickDrag) AsAny() any { return u.any }

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigsLeftClickDrag) GetDeferLoading() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserLeftClickDragConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	case *BetaComputerLeftClickDragConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigsLeftClickDrag) GetEnabled() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserLeftClickDragConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	case *BetaComputerLeftClickDragConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	}
	return nil
}

// Returns a subunion which exports methods to access subproperties
//
// Or use AsAny() to get the underlying value
func (u betaToolUnionParamConfigs) GetLeftMouseDown() (res betaToolUnionParamConfigsLeftMouseDown) {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		res.any = &vt.LeftMouseDown
	case *BetaComputerToolsetConfigsParam:
		res.any = &vt.LeftMouseDown
	}
	return res
}

// Can have the runtime types [*BetaBrowserLeftMouseDownConfigParam],
// [*BetaComputerLeftMouseDownConfigParam]
type betaToolUnionParamConfigsLeftMouseDown struct{ any }

// Use the following switch statement to get the type of the union:
//
//	switch u.AsAny().(type) {
//	case *anthropic.BetaBrowserLeftMouseDownConfigParam:
//	case *anthropic.BetaComputerLeftMouseDownConfigParam:
//	default:
//	    fmt.Errorf("not present")
//	}
func (u betaToolUnionParamConfigsLeftMouseDown) AsAny() any { return u.any }

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigsLeftMouseDown) GetDeferLoading() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserLeftMouseDownConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	case *BetaComputerLeftMouseDownConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigsLeftMouseDown) GetEnabled() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserLeftMouseDownConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	case *BetaComputerLeftMouseDownConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	}
	return nil
}

// Returns a subunion which exports methods to access subproperties
//
// Or use AsAny() to get the underlying value
func (u betaToolUnionParamConfigs) GetLeftMouseUp() (res betaToolUnionParamConfigsLeftMouseUp) {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		res.any = &vt.LeftMouseUp
	case *BetaComputerToolsetConfigsParam:
		res.any = &vt.LeftMouseUp
	}
	return res
}

// Can have the runtime types [*BetaBrowserLeftMouseUpConfigParam],
// [*BetaComputerLeftMouseUpConfigParam]
type betaToolUnionParamConfigsLeftMouseUp struct{ any }

// Use the following switch statement to get the type of the union:
//
//	switch u.AsAny().(type) {
//	case *anthropic.BetaBrowserLeftMouseUpConfigParam:
//	case *anthropic.BetaComputerLeftMouseUpConfigParam:
//	default:
//	    fmt.Errorf("not present")
//	}
func (u betaToolUnionParamConfigsLeftMouseUp) AsAny() any { return u.any }

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigsLeftMouseUp) GetDeferLoading() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserLeftMouseUpConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	case *BetaComputerLeftMouseUpConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigsLeftMouseUp) GetEnabled() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserLeftMouseUpConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	case *BetaComputerLeftMouseUpConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	}
	return nil
}

// Returns a subunion which exports methods to access subproperties
//
// Or use AsAny() to get the underlying value
func (u betaToolUnionParamConfigs) GetMiddleClick() (res betaToolUnionParamConfigsMiddleClick) {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		res.any = &vt.MiddleClick
	case *BetaComputerToolsetConfigsParam:
		res.any = &vt.MiddleClick
	}
	return res
}

// Can have the runtime types [*BetaBrowserMiddleClickConfigParam],
// [*BetaComputerMiddleClickConfigParam]
type betaToolUnionParamConfigsMiddleClick struct{ any }

// Use the following switch statement to get the type of the union:
//
//	switch u.AsAny().(type) {
//	case *anthropic.BetaBrowserMiddleClickConfigParam:
//	case *anthropic.BetaComputerMiddleClickConfigParam:
//	default:
//	    fmt.Errorf("not present")
//	}
func (u betaToolUnionParamConfigsMiddleClick) AsAny() any { return u.any }

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigsMiddleClick) GetDeferLoading() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserMiddleClickConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	case *BetaComputerMiddleClickConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigsMiddleClick) GetEnabled() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserMiddleClickConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	case *BetaComputerMiddleClickConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	}
	return nil
}

// Returns a subunion which exports methods to access subproperties
//
// Or use AsAny() to get the underlying value
func (u betaToolUnionParamConfigs) GetMouseMove() (res betaToolUnionParamConfigsMouseMove) {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		res.any = &vt.MouseMove
	case *BetaComputerToolsetConfigsParam:
		res.any = &vt.MouseMove
	}
	return res
}

// Can have the runtime types [*BetaBrowserMouseMoveConfigParam],
// [*BetaComputerMouseMoveConfigParam]
type betaToolUnionParamConfigsMouseMove struct{ any }

// Use the following switch statement to get the type of the union:
//
//	switch u.AsAny().(type) {
//	case *anthropic.BetaBrowserMouseMoveConfigParam:
//	case *anthropic.BetaComputerMouseMoveConfigParam:
//	default:
//	    fmt.Errorf("not present")
//	}
func (u betaToolUnionParamConfigsMouseMove) AsAny() any { return u.any }

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigsMouseMove) GetDeferLoading() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserMouseMoveConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	case *BetaComputerMouseMoveConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigsMouseMove) GetEnabled() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserMouseMoveConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	case *BetaComputerMouseMoveConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	}
	return nil
}

// Returns a subunion which exports methods to access subproperties
//
// Or use AsAny() to get the underlying value
func (u betaToolUnionParamConfigs) GetRightClick() (res betaToolUnionParamConfigsRightClick) {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		res.any = &vt.RightClick
	case *BetaComputerToolsetConfigsParam:
		res.any = &vt.RightClick
	}
	return res
}

// Can have the runtime types [*BetaBrowserRightClickConfigParam],
// [*BetaComputerRightClickConfigParam]
type betaToolUnionParamConfigsRightClick struct{ any }

// Use the following switch statement to get the type of the union:
//
//	switch u.AsAny().(type) {
//	case *anthropic.BetaBrowserRightClickConfigParam:
//	case *anthropic.BetaComputerRightClickConfigParam:
//	default:
//	    fmt.Errorf("not present")
//	}
func (u betaToolUnionParamConfigsRightClick) AsAny() any { return u.any }

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigsRightClick) GetDeferLoading() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserRightClickConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	case *BetaComputerRightClickConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigsRightClick) GetEnabled() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserRightClickConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	case *BetaComputerRightClickConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	}
	return nil
}

// Returns a subunion which exports methods to access subproperties
//
// Or use AsAny() to get the underlying value
func (u betaToolUnionParamConfigs) GetScreenshot() (res betaToolUnionParamConfigsScreenshot) {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		res.any = &vt.Screenshot
	case *BetaComputerToolsetConfigsParam:
		res.any = &vt.Screenshot
	}
	return res
}

// Can have the runtime types [*BetaBrowserScreenshotConfigParam],
// [*BetaComputerScreenshotConfigParam]
type betaToolUnionParamConfigsScreenshot struct{ any }

// Use the following switch statement to get the type of the union:
//
//	switch u.AsAny().(type) {
//	case *anthropic.BetaBrowserScreenshotConfigParam:
//	case *anthropic.BetaComputerScreenshotConfigParam:
//	default:
//	    fmt.Errorf("not present")
//	}
func (u betaToolUnionParamConfigsScreenshot) AsAny() any { return u.any }

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigsScreenshot) GetDeferLoading() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserScreenshotConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	case *BetaComputerScreenshotConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigsScreenshot) GetEnabled() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserScreenshotConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	case *BetaComputerScreenshotConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	}
	return nil
}

// Returns a subunion which exports methods to access subproperties
//
// Or use AsAny() to get the underlying value
func (u betaToolUnionParamConfigs) GetScroll() (res betaToolUnionParamConfigsScroll) {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		res.any = &vt.Scroll
	case *BetaComputerToolsetConfigsParam:
		res.any = &vt.Scroll
	}
	return res
}

// Can have the runtime types [*BetaBrowserScrollConfigParam],
// [*BetaComputerScrollConfigParam]
type betaToolUnionParamConfigsScroll struct{ any }

// Use the following switch statement to get the type of the union:
//
//	switch u.AsAny().(type) {
//	case *anthropic.BetaBrowserScrollConfigParam:
//	case *anthropic.BetaComputerScrollConfigParam:
//	default:
//	    fmt.Errorf("not present")
//	}
func (u betaToolUnionParamConfigsScroll) AsAny() any { return u.any }

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigsScroll) GetDeferLoading() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserScrollConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	case *BetaComputerScrollConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigsScroll) GetEnabled() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserScrollConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	case *BetaComputerScrollConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	}
	return nil
}

// Returns a subunion which exports methods to access subproperties
//
// Or use AsAny() to get the underlying value
func (u betaToolUnionParamConfigs) GetTripleClick() (res betaToolUnionParamConfigsTripleClick) {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		res.any = &vt.TripleClick
	case *BetaComputerToolsetConfigsParam:
		res.any = &vt.TripleClick
	}
	return res
}

// Can have the runtime types [*BetaBrowserTripleClickConfigParam],
// [*BetaComputerTripleClickConfigParam]
type betaToolUnionParamConfigsTripleClick struct{ any }

// Use the following switch statement to get the type of the union:
//
//	switch u.AsAny().(type) {
//	case *anthropic.BetaBrowserTripleClickConfigParam:
//	case *anthropic.BetaComputerTripleClickConfigParam:
//	default:
//	    fmt.Errorf("not present")
//	}
func (u betaToolUnionParamConfigsTripleClick) AsAny() any { return u.any }

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigsTripleClick) GetDeferLoading() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserTripleClickConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	case *BetaComputerTripleClickConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigsTripleClick) GetEnabled() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserTripleClickConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	case *BetaComputerTripleClickConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	}
	return nil
}

// Returns a subunion which exports methods to access subproperties
//
// Or use AsAny() to get the underlying value
func (u betaToolUnionParamConfigs) GetType() (res betaToolUnionParamConfigsType) {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		res.any = &vt.Type
	case *BetaComputerToolsetConfigsParam:
		res.any = &vt.Type
	}
	return res
}

// Can have the runtime types [*BetaBrowserTypeConfigParam],
// [*BetaComputerTypeConfigParam]
type betaToolUnionParamConfigsType struct{ any }

// Use the following switch statement to get the type of the union:
//
//	switch u.AsAny().(type) {
//	case *anthropic.BetaBrowserTypeConfigParam:
//	case *anthropic.BetaComputerTypeConfigParam:
//	default:
//	    fmt.Errorf("not present")
//	}
func (u betaToolUnionParamConfigsType) AsAny() any { return u.any }

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigsType) GetDeferLoading() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserTypeConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	case *BetaComputerTypeConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigsType) GetEnabled() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserTypeConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	case *BetaComputerTypeConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	}
	return nil
}

// Returns a subunion which exports methods to access subproperties
//
// Or use AsAny() to get the underlying value
func (u betaToolUnionParamConfigs) GetWait() (res betaToolUnionParamConfigsWait) {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		res.any = &vt.Wait
	case *BetaComputerToolsetConfigsParam:
		res.any = &vt.Wait
	}
	return res
}

// Can have the runtime types [*BetaBrowserWaitConfigParam],
// [*BetaComputerWaitConfigParam]
type betaToolUnionParamConfigsWait struct{ any }

// Use the following switch statement to get the type of the union:
//
//	switch u.AsAny().(type) {
//	case *anthropic.BetaBrowserWaitConfigParam:
//	case *anthropic.BetaComputerWaitConfigParam:
//	default:
//	    fmt.Errorf("not present")
//	}
func (u betaToolUnionParamConfigsWait) AsAny() any { return u.any }

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigsWait) GetDeferLoading() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserWaitConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	case *BetaComputerWaitConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigsWait) GetEnabled() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserWaitConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	case *BetaComputerWaitConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	}
	return nil
}

// Returns a subunion which exports methods to access subproperties
//
// Or use AsAny() to get the underlying value
func (u betaToolUnionParamConfigs) GetZoom() (res betaToolUnionParamConfigsZoom) {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		res.any = &vt.Zoom
	case *BetaComputerToolsetConfigsParam:
		res.any = &vt.Zoom
	}
	return res
}

// Can have the runtime types [*BetaBrowserZoomConfigParam],
// [*BetaComputerZoomConfigParam]
type betaToolUnionParamConfigsZoom struct{ any }

// Use the following switch statement to get the type of the union:
//
//	switch u.AsAny().(type) {
//	case *anthropic.BetaBrowserZoomConfigParam:
//	case *anthropic.BetaComputerZoomConfigParam:
//	default:
//	    fmt.Errorf("not present")
//	}
func (u betaToolUnionParamConfigsZoom) AsAny() any { return u.any }

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigsZoom) GetDeferLoading() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserZoomConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	case *BetaComputerZoomConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaToolUnionParamConfigsZoom) GetEnabled() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserZoomConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	case *BetaComputerZoomConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	}
	return nil
}

// Returns a pointer to the underlying variant's AllowedDomains property, if
// present.
func (u BetaToolUnionParam) GetAllowedDomains() []string {
	if vt := u.OfWebSearchTool20250305; vt != nil {
		return vt.AllowedDomains
	} else if vt := u.OfWebFetchTool20250910; vt != nil {
		return vt.AllowedDomains
	} else if vt := u.OfWebSearchTool20260209; vt != nil {
		return vt.AllowedDomains
	} else if vt := u.OfWebFetchTool20260209; vt != nil {
		return vt.AllowedDomains
	} else if vt := u.OfWebFetchTool20260309; vt != nil {
		return vt.AllowedDomains
	} else if vt := u.OfWebSearchTool20260318; vt != nil {
		return vt.AllowedDomains
	} else if vt := u.OfWebFetchTool20260318; vt != nil {
		return vt.AllowedDomains
	}
	return nil
}

// Returns a pointer to the underlying variant's BlockedDomains property, if
// present.
func (u BetaToolUnionParam) GetBlockedDomains() []string {
	if vt := u.OfWebSearchTool20250305; vt != nil {
		return vt.BlockedDomains
	} else if vt := u.OfWebFetchTool20250910; vt != nil {
		return vt.BlockedDomains
	} else if vt := u.OfWebSearchTool20260209; vt != nil {
		return vt.BlockedDomains
	} else if vt := u.OfWebFetchTool20260209; vt != nil {
		return vt.BlockedDomains
	} else if vt := u.OfWebFetchTool20260309; vt != nil {
		return vt.BlockedDomains
	} else if vt := u.OfWebSearchTool20260318; vt != nil {
		return vt.BlockedDomains
	} else if vt := u.OfWebFetchTool20260318; vt != nil {
		return vt.BlockedDomains
	}
	return nil
}

// Returns a pointer to the underlying variant's UserLocation property, if present.
func (u BetaToolUnionParam) GetUserLocation() *BetaUserLocationParam {
	if vt := u.OfWebSearchTool20250305; vt != nil {
		return &vt.UserLocation
	} else if vt := u.OfWebSearchTool20260209; vt != nil {
		return &vt.UserLocation
	} else if vt := u.OfWebSearchTool20260318; vt != nil {
		return &vt.UserLocation
	}
	return nil
}

// Returns a pointer to the underlying variant's Citations property, if present.
func (u BetaToolUnionParam) GetCitations() *BetaCitationsConfigParam {
	if vt := u.OfWebFetchTool20250910; vt != nil {
		return &vt.Citations
	} else if vt := u.OfWebFetchTool20260209; vt != nil {
		return &vt.Citations
	} else if vt := u.OfWebFetchTool20260309; vt != nil {
		return &vt.Citations
	} else if vt := u.OfWebFetchTool20260318; vt != nil {
		return &vt.Citations
	}
	return nil
}

type BetaToolUseBlock struct {
	ID    string           `json:"id" api:"required"`
	Input any              `json:"input" api:"required"`
	Name  string           `json:"name" api:"required"`
	Type  constant.ToolUse `json:"type" default:"tool_use"`
	// Tool invocation directly from the model.
	Caller BetaToolUseBlockCallerUnion `json:"caller"`
	// For a toolset member tool_use, the toolset family.
	ToolsetName string `json:"toolset_name" api:"nullable"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Input       respjson.Field
		Name        respjson.Field
		Type        respjson.Field
		Caller      respjson.Field
		ToolsetName respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaToolUseBlock) RawJSON() string { return r.JSON.raw }
func (r *BetaToolUseBlock) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// BetaToolUseBlockCallerUnion contains all possible properties and values from
// [BetaDirectCaller], [BetaServerToolCaller], [BetaServerToolCaller20260120].
//
// Use the [BetaToolUseBlockCallerUnion.AsAny] method to switch on the variant.
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
type BetaToolUseBlockCallerUnion struct {
	// Any of "direct", "code_execution_20250825", "code_execution_20260120".
	Type   string `json:"type"`
	ToolID string `json:"tool_id"`
	JSON   struct {
		Type   respjson.Field
		ToolID respjson.Field
		raw    string
	} `json:"-"`
}

// anyBetaToolUseBlockCaller is implemented by each variant of
// [BetaToolUseBlockCallerUnion] to add type safety for the return type of
// [BetaToolUseBlockCallerUnion.AsAny]
type anyBetaToolUseBlockCaller interface {
	implBetaToolUseBlockCallerUnion()
}

func (BetaDirectCaller) implBetaToolUseBlockCallerUnion()             {}
func (BetaServerToolCaller) implBetaToolUseBlockCallerUnion()         {}
func (BetaServerToolCaller20260120) implBetaToolUseBlockCallerUnion() {}

// Use the following switch statement to find the correct variant
//
//	switch variant := BetaToolUseBlockCallerUnion.AsAny().(type) {
//	case anthropic.BetaDirectCaller:
//	case anthropic.BetaServerToolCaller:
//	case anthropic.BetaServerToolCaller20260120:
//	default:
//	  fmt.Errorf("no variant present")
//	}
func (u BetaToolUseBlockCallerUnion) AsAny() anyBetaToolUseBlockCaller {
	switch u.Type {
	case "direct":
		return u.AsDirect()
	case "code_execution_20250825":
		return u.AsCodeExecution20250825()
	case "code_execution_20260120":
		return u.AsCodeExecution20260120()
	}
	return nil
}

func (u BetaToolUseBlockCallerUnion) AsDirect() (v BetaDirectCaller) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaToolUseBlockCallerUnion) AsCodeExecution20250825() (v BetaServerToolCaller) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaToolUseBlockCallerUnion) AsCodeExecution20260120() (v BetaServerToolCaller20260120) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u BetaToolUseBlockCallerUnion) RawJSON() string { return u.JSON.raw }

func (r *BetaToolUseBlockCallerUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties ID, Input, Name, Type are required.
type BetaToolUseBlockParam struct {
	ID    string `json:"id" api:"required"`
	Input any    `json:"input,omitzero" api:"required"`
	Name  string `json:"name" api:"required"`
	// For a toolset member tool_use, the toolset family this member belongs to.
	ToolsetName param.Opt[string] `json:"toolset_name,omitzero"`
	// Create a cache control breakpoint at this content block.
	CacheControl BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	// Tool invocation directly from the model.
	Caller BetaToolUseBlockParamCallerUnion `json:"caller,omitzero"`
	// This field can be elided, and will marshal its zero value as "tool_use".
	Type constant.ToolUse `json:"type" default:"tool_use"`
	paramObj
}

func (r BetaToolUseBlockParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaToolUseBlockParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaToolUseBlockParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Only one field can be non-zero.
//
// Use [param.IsOmitted] to confirm if a field is set.
type BetaToolUseBlockParamCallerUnion struct {
	OfDirect                *BetaDirectCallerParam             `json:",omitzero,inline"`
	OfCodeExecution20250825 *BetaServerToolCallerParam         `json:",omitzero,inline"`
	OfCodeExecution20260120 *BetaServerToolCaller20260120Param `json:",omitzero,inline"`
	paramUnion
}

func (u BetaToolUseBlockParamCallerUnion) MarshalJSON() ([]byte, error) {
	return param.MarshalUnion(u, u.OfDirect, u.OfCodeExecution20250825, u.OfCodeExecution20260120)
}
func (u *BetaToolUseBlockParamCallerUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, u)
}

func (u *BetaToolUseBlockParamCallerUnion) asAny() any {
	if !param.IsOmitted(u.OfDirect) {
		return u.OfDirect
	} else if !param.IsOmitted(u.OfCodeExecution20250825) {
		return u.OfCodeExecution20250825
	} else if !param.IsOmitted(u.OfCodeExecution20260120) {
		return u.OfCodeExecution20260120
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaToolUseBlockParamCallerUnion) GetType() *string {
	if vt := u.OfDirect; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfCodeExecution20250825; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfCodeExecution20260120; vt != nil {
		return (*string)(&vt.Type)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaToolUseBlockParamCallerUnion) GetToolID() *string {
	if vt := u.OfCodeExecution20250825; vt != nil {
		return (*string)(&vt.ToolID)
	} else if vt := u.OfCodeExecution20260120; vt != nil {
		return (*string)(&vt.ToolID)
	}
	return nil
}

func init() {
	apijson.RegisterUnion[BetaToolUseBlockParamCallerUnion](
		"type",
		apijson.Discriminator[BetaDirectCallerParam]("direct"),
		apijson.Discriminator[BetaServerToolCallerParam]("code_execution_20250825"),
		apijson.Discriminator[BetaServerToolCaller20260120Param]("code_execution_20260120"),
	)
}

// The properties Type, Value are required.
type BetaToolUsesKeepParam struct {
	Value int64 `json:"value" api:"required"`
	// This field can be elided, and will marshal its zero value as "tool_uses".
	Type constant.ToolUses `json:"type" default:"tool_uses"`
	paramObj
}

func (r BetaToolUsesKeepParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaToolUsesKeepParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaToolUsesKeepParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties Type, Value are required.
type BetaToolUsesTriggerParam struct {
	Value int64 `json:"value" api:"required"`
	// This field can be elided, and will marshal its zero value as "tool_uses".
	Type constant.ToolUses `json:"type" default:"tool_uses"`
	paramObj
}

func (r BetaToolUsesTriggerParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaToolUsesTriggerParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaToolUsesTriggerParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties Type, URL are required.
type BetaURLImageSourceParam struct {
	URL string `json:"url" api:"required"`
	// This field can be elided, and will marshal its zero value as "url".
	Type constant.URL `json:"type" default:"url"`
	paramObj
}

func (r BetaURLImageSourceParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaURLImageSourceParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaURLImageSourceParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties Type, URL are required.
type BetaURLPDFSourceParam struct {
	URL string `json:"url" api:"required"`
	// This field can be elided, and will marshal its zero value as "url".
	Type constant.URL `json:"type" default:"url"`
	paramObj
}

func (r BetaURLPDFSourceParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaURLPDFSourceParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaURLPDFSourceParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaUsage struct {
	// Breakdown of cached tokens by TTL
	CacheCreation BetaCacheCreation `json:"cache_creation" api:"required"`
	// The number of input tokens used to create the cache entry.
	CacheCreationInputTokens int64 `json:"cache_creation_input_tokens" api:"required"`
	// The number of input tokens read from the cache.
	CacheReadInputTokens int64 `json:"cache_read_input_tokens" api:"required"`
	// Outcome of the `fallback_credit_token` presented on this request.
	FallbackCredit BetaFallbackCreditUsage `json:"fallback_credit" api:"required"`
	// The geographic region where inference was performed for this request.
	InferenceGeo string `json:"inference_geo" api:"required"`
	// The number of input tokens which were used.
	InputTokens int64 `json:"input_tokens" api:"required"`
	// Per-iteration token usage breakdown.
	//
	// Each entry represents one sampling iteration, with its own input/output token
	// counts and cache statistics, discriminated by `type`. For `message` entries
	// (model sampling iterations, such as the turns of a server-side tool use loop),
	// this allows you to:
	//
	// - Determine which iterations exceeded long context thresholds (>=200k tokens)
	// - Calculate the context window size from the last `message` entry
	// - Understand token accumulation across server-side tool use loops
	//
	// A `compaction` entry reports the token usage of the compaction operation itself
	// — the server-side request that summarizes the context being closed — NOT the
	// size of the context that was compacted away, and its token counts can be much
	// smaller than that closed context (for example, a compaction that closes a
	// ~200k-token context can report only a few thousand tokens). Do not derive the
	// context window size from a `compaction` entry, even when it is the last entry. A
	// `compaction` entry's tokens are not included in the top-level `usage` fields.
	// When an input-token trigger is in effect (the default — 150,000 tokens unless
	// configured otherwise), each `compaction` entry closes a context that had reached
	// at least that threshold, though the context can exceed it by the final
	// iteration's output and tool results.
	Iterations BetaIterationsUsage `json:"iterations" api:"required"`
	// The number of output tokens which were used.
	OutputTokens int64 `json:"output_tokens" api:"required"`
	// Breakdown of output tokens by category.
	//
	// `output_tokens` remains the inclusive, authoritative total used for billing.
	// This object provides a read-only decomposition for observability — for example,
	// how many of the billed output tokens were spent on internal reasoning that may
	// have been summarized before being returned to you.
	OutputTokensDetails BetaOutputTokensDetails `json:"output_tokens_details" api:"required"`
	// The number of server tool requests.
	ServerToolUse BetaServerToolUsage `json:"server_tool_use" api:"required"`
	// If the request used the priority, standard, or batch tier.
	//
	// Any of "standard", "priority", "batch".
	ServiceTier BetaUsageServiceTier `json:"service_tier" api:"required"`
	// Inference speed mode. `fast` provides significantly faster output token
	// generation at premium pricing. Not all models support `fast`; invalid
	// combinations are rejected at create time.
	//
	// Any of "standard", "fast".
	Speed BetaUsageSpeed `json:"speed" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CacheCreation            respjson.Field
		CacheCreationInputTokens respjson.Field
		CacheReadInputTokens     respjson.Field
		FallbackCredit           respjson.Field
		InferenceGeo             respjson.Field
		InputTokens              respjson.Field
		Iterations               respjson.Field
		OutputTokens             respjson.Field
		OutputTokensDetails      respjson.Field
		ServerToolUse            respjson.Field
		ServiceTier              respjson.Field
		Speed                    respjson.Field
		ExtraFields              map[string]respjson.Field
		raw                      string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaUsage) RawJSON() string { return r.JSON.raw }
func (r *BetaUsage) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// If the request used the priority, standard, or batch tier.
type BetaUsageServiceTier string

const (
	BetaUsageServiceTierStandard BetaUsageServiceTier = "standard"
	BetaUsageServiceTierPriority BetaUsageServiceTier = "priority"
	BetaUsageServiceTierBatch    BetaUsageServiceTier = "batch"
)

// Inference speed mode. `fast` provides significantly faster output token
// generation at premium pricing. Not all models support `fast`; invalid
// combinations are rejected at create time.
type BetaUsageSpeed string

const (
	BetaUsageSpeedStandard BetaUsageSpeed = "standard"
	BetaUsageSpeedFast     BetaUsageSpeed = "fast"
)

// The property Type is required.
type BetaUserLocationParam struct {
	// The city of the user.
	City param.Opt[string] `json:"city,omitzero"`
	// The two letter
	// [ISO country code](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2) of the
	// user.
	Country param.Opt[string] `json:"country,omitzero"`
	// The region of the user.
	Region param.Opt[string] `json:"region,omitzero"`
	// The [IANA timezone](https://nodatime.org/TimeZones) of the user.
	Timezone param.Opt[string] `json:"timezone,omitzero"`
	// This field can be elided, and will marshal its zero value as "approximate".
	Type constant.Approximate `json:"type" default:"approximate"`
	paramObj
}

func (r BetaUserLocationParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaUserLocationParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaUserLocationParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaWebFetchBlock struct {
	Content BetaDocumentBlock `json:"content" api:"required"`
	// ISO 8601 timestamp when the content was retrieved
	RetrievedAt string                  `json:"retrieved_at" api:"required"`
	Type        constant.WebFetchResult `json:"type" default:"web_fetch_result"`
	// Fetched content URL
	URL string `json:"url" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Content     respjson.Field
		RetrievedAt respjson.Field
		Type        respjson.Field
		URL         respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaWebFetchBlock) RawJSON() string { return r.JSON.raw }
func (r *BetaWebFetchBlock) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties Content, Type, URL are required.
type BetaWebFetchBlockParam struct {
	Content BetaRequestDocumentBlockParam `json:"content,omitzero" api:"required"`
	// Fetched content URL
	URL string `json:"url" api:"required"`
	// ISO 8601 timestamp when the content was retrieved
	RetrievedAt param.Opt[string] `json:"retrieved_at,omitzero"`
	// This field can be elided, and will marshal its zero value as "web_fetch_result".
	Type constant.WebFetchResult `json:"type" default:"web_fetch_result"`
	paramObj
}

func (r BetaWebFetchBlockParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaWebFetchBlockParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaWebFetchBlockParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties Name, Type are required.
type BetaWebFetchTool20250910Param struct {
	// Maximum number of tokens used by including web page text content in the context.
	// The limit is approximate and does not apply to binary content such as PDFs.
	MaxContentTokens param.Opt[int64] `json:"max_content_tokens,omitzero"`
	// Maximum number of times the tool can be used in the API request.
	MaxUses param.Opt[int64] `json:"max_uses,omitzero"`
	// If true, tool will not be included in initial system prompt. Only loaded when
	// returned via tool_reference from tool search.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// When true, guarantees schema validation on tool names and inputs
	Strict param.Opt[bool] `json:"strict,omitzero"`
	// List of domains to allow fetching from
	AllowedDomains []string `json:"allowed_domains,omitzero"`
	// List of domains to block fetching from
	BlockedDomains []string `json:"blocked_domains,omitzero"`
	// Any of "direct", "code_execution_20250825", "code_execution_20260120",
	// "code_execution_20260521".
	AllowedCallers []string `json:"allowed_callers,omitzero"`
	// Create a cache control breakpoint at this content block.
	CacheControl BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	// Citations configuration for fetched documents. Citations are disabled by
	// default.
	Citations BetaCitationsConfigParam `json:"citations,omitzero"`
	// Name of the tool.
	//
	// This is how the tool will be called by the model and in `tool_use` blocks.
	//
	// This field can be elided, and will marshal its zero value as "web_fetch".
	Name constant.WebFetch `json:"name" default:"web_fetch"`
	// This field can be elided, and will marshal its zero value as
	// "web_fetch_20250910".
	Type constant.WebFetch20250910 `json:"type" default:"web_fetch_20250910"`
	paramObj
}

func (r BetaWebFetchTool20250910Param) MarshalJSON() (data []byte, err error) {
	type shadow BetaWebFetchTool20250910Param
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaWebFetchTool20250910Param) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties Name, Type are required.
type BetaWebFetchTool20260209Param struct {
	// Maximum number of tokens used by including web page text content in the context.
	// The limit is approximate and does not apply to binary content such as PDFs.
	MaxContentTokens param.Opt[int64] `json:"max_content_tokens,omitzero"`
	// Maximum number of times the tool can be used in the API request.
	MaxUses param.Opt[int64] `json:"max_uses,omitzero"`
	// If true, tool will not be included in initial system prompt. Only loaded when
	// returned via tool_reference from tool search.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// When true, guarantees schema validation on tool names and inputs
	Strict param.Opt[bool] `json:"strict,omitzero"`
	// List of domains to allow fetching from
	AllowedDomains []string `json:"allowed_domains,omitzero"`
	// List of domains to block fetching from
	BlockedDomains []string `json:"blocked_domains,omitzero"`
	// Any of "direct", "code_execution_20250825", "code_execution_20260120",
	// "code_execution_20260521".
	AllowedCallers []string `json:"allowed_callers,omitzero"`
	// Create a cache control breakpoint at this content block.
	CacheControl BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	// Citations configuration for fetched documents. Citations are disabled by
	// default.
	Citations BetaCitationsConfigParam `json:"citations,omitzero"`
	// Name of the tool.
	//
	// This is how the tool will be called by the model and in `tool_use` blocks.
	//
	// This field can be elided, and will marshal its zero value as "web_fetch".
	Name constant.WebFetch `json:"name" default:"web_fetch"`
	// This field can be elided, and will marshal its zero value as
	// "web_fetch_20260209".
	Type constant.WebFetch20260209 `json:"type" default:"web_fetch_20260209"`
	paramObj
}

func (r BetaWebFetchTool20260209Param) MarshalJSON() (data []byte, err error) {
	type shadow BetaWebFetchTool20260209Param
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaWebFetchTool20260209Param) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Web fetch tool with use_cache parameter for bypassing cached content.
//
// The properties Name, Type are required.
type BetaWebFetchTool20260309Param struct {
	// Maximum number of tokens used by including web page text content in the context.
	// The limit is approximate and does not apply to binary content such as PDFs.
	MaxContentTokens param.Opt[int64] `json:"max_content_tokens,omitzero"`
	// Maximum number of times the tool can be used in the API request.
	MaxUses param.Opt[int64] `json:"max_uses,omitzero"`
	// If true, tool will not be included in initial system prompt. Only loaded when
	// returned via tool_reference from tool search.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// When true, guarantees schema validation on tool names and inputs
	Strict param.Opt[bool] `json:"strict,omitzero"`
	// Whether to use cached content. Set to false to bypass the cache and fetch fresh
	// content. Only set to false when the user explicitly requests fresh content or
	// when fetching rapidly-changing sources.
	UseCache param.Opt[bool] `json:"use_cache,omitzero"`
	// List of domains to allow fetching from
	AllowedDomains []string `json:"allowed_domains,omitzero"`
	// List of domains to block fetching from
	BlockedDomains []string `json:"blocked_domains,omitzero"`
	// Any of "direct", "code_execution_20250825", "code_execution_20260120",
	// "code_execution_20260521".
	AllowedCallers []string `json:"allowed_callers,omitzero"`
	// Create a cache control breakpoint at this content block.
	CacheControl BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	// Citations configuration for fetched documents. Citations are disabled by
	// default.
	Citations BetaCitationsConfigParam `json:"citations,omitzero"`
	// Name of the tool.
	//
	// This is how the tool will be called by the model and in `tool_use` blocks.
	//
	// This field can be elided, and will marshal its zero value as "web_fetch".
	Name constant.WebFetch `json:"name" default:"web_fetch"`
	// This field can be elided, and will marshal its zero value as
	// "web_fetch_20260309".
	Type constant.WebFetch20260309 `json:"type" default:"web_fetch_20260309"`
	paramObj
}

func (r BetaWebFetchTool20260309Param) MarshalJSON() (data []byte, err error) {
	type shadow BetaWebFetchTool20260309Param
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaWebFetchTool20260309Param) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties Name, Type are required.
type BetaWebFetchTool20260318Param struct {
	// Maximum number of tokens used by including web page text content in the context.
	// The limit is approximate and does not apply to binary content such as PDFs.
	MaxContentTokens param.Opt[int64] `json:"max_content_tokens,omitzero"`
	// Maximum number of times the tool can be used in the API request.
	MaxUses param.Opt[int64] `json:"max_uses,omitzero"`
	// If true, tool will not be included in initial system prompt. Only loaded when
	// returned via tool_reference from tool search.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// When true, guarantees schema validation on tool names and inputs
	Strict param.Opt[bool] `json:"strict,omitzero"`
	// Whether to use cached content. Set to false to bypass the cache and fetch fresh
	// content. Only set to false when the user explicitly requests fresh content or
	// when fetching rapidly-changing sources.
	UseCache param.Opt[bool] `json:"use_cache,omitzero"`
	// List of domains to allow fetching from
	AllowedDomains []string `json:"allowed_domains,omitzero"`
	// List of domains to block fetching from
	BlockedDomains []string `json:"blocked_domains,omitzero"`
	// Any of "direct", "code_execution_20250825", "code_execution_20260120",
	// "code_execution_20260521".
	AllowedCallers []string `json:"allowed_callers,omitzero"`
	// Create a cache control breakpoint at this content block.
	CacheControl BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	// Citations configuration for fetched documents. Citations are disabled by
	// default.
	Citations BetaCitationsConfigParam `json:"citations,omitzero"`
	// How this tool's result blocks appear in the API response when the result was
	// consumed by a completed code_execution call in the same turn. 'full' returns the
	// complete content (default). 'excluded' drops the nested server_tool_use and
	// result block pair entirely. Results from direct calls, or from code_execution
	// calls that paused before completing, are always returned in full so they can be
	// sent back on the next turn.
	//
	// Any of "full", "excluded".
	ResponseInclusion BetaWebFetchTool20260318ResponseInclusion `json:"response_inclusion,omitzero"`
	// Name of the tool.
	//
	// This is how the tool will be called by the model and in `tool_use` blocks.
	//
	// This field can be elided, and will marshal its zero value as "web_fetch".
	Name constant.WebFetch `json:"name" default:"web_fetch"`
	// This field can be elided, and will marshal its zero value as
	// "web_fetch_20260318".
	Type constant.WebFetch20260318 `json:"type" default:"web_fetch_20260318"`
	paramObj
}

func (r BetaWebFetchTool20260318Param) MarshalJSON() (data []byte, err error) {
	type shadow BetaWebFetchTool20260318Param
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaWebFetchTool20260318Param) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// How this tool's result blocks appear in the API response when the result was
// consumed by a completed code_execution call in the same turn. 'full' returns the
// complete content (default). 'excluded' drops the nested server_tool_use and
// result block pair entirely. Results from direct calls, or from code_execution
// calls that paused before completing, are always returned in full so they can be
// sent back on the next turn.
type BetaWebFetchTool20260318ResponseInclusion string

const (
	BetaWebFetchTool20260318ResponseInclusionFull     BetaWebFetchTool20260318ResponseInclusion = "full"
	BetaWebFetchTool20260318ResponseInclusionExcluded BetaWebFetchTool20260318ResponseInclusion = "excluded"
)

type BetaWebFetchToolResultBlock struct {
	Content   BetaWebFetchToolResultBlockContentUnion `json:"content" api:"required"`
	ToolUseID string                                  `json:"tool_use_id" api:"required"`
	Type      constant.WebFetchToolResult             `json:"type" default:"web_fetch_tool_result"`
	// Tool invocation directly from the model.
	Caller BetaWebFetchToolResultBlockCallerUnion `json:"caller"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Content     respjson.Field
		ToolUseID   respjson.Field
		Type        respjson.Field
		Caller      respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaWebFetchToolResultBlock) RawJSON() string { return r.JSON.raw }
func (r *BetaWebFetchToolResultBlock) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// BetaWebFetchToolResultBlockContentUnion contains all possible properties and
// values from [BetaWebFetchToolResultErrorBlock], [BetaWebFetchBlock].
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
type BetaWebFetchToolResultBlockContentUnion struct {
	// This field is from variant [BetaWebFetchToolResultErrorBlock].
	ErrorCode BetaWebFetchToolResultErrorCode `json:"error_code"`
	Type      string                          `json:"type"`
	// This field is from variant [BetaWebFetchBlock].
	Content BetaDocumentBlock `json:"content"`
	// This field is from variant [BetaWebFetchBlock].
	RetrievedAt string `json:"retrieved_at"`
	// This field is from variant [BetaWebFetchBlock].
	URL  string `json:"url"`
	JSON struct {
		ErrorCode   respjson.Field
		Type        respjson.Field
		Content     respjson.Field
		RetrievedAt respjson.Field
		URL         respjson.Field
		raw         string
	} `json:"-"`
}

func (u BetaWebFetchToolResultBlockContentUnion) AsResponseWebFetchToolResultError() (v BetaWebFetchToolResultErrorBlock) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaWebFetchToolResultBlockContentUnion) AsResponseWebFetchResultBlock() (v BetaWebFetchBlock) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u BetaWebFetchToolResultBlockContentUnion) RawJSON() string { return u.JSON.raw }

func (r *BetaWebFetchToolResultBlockContentUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// BetaWebFetchToolResultBlockCallerUnion contains all possible properties and
// values from [BetaDirectCaller], [BetaServerToolCaller],
// [BetaServerToolCaller20260120].
//
// Use the [BetaWebFetchToolResultBlockCallerUnion.AsAny] method to switch on the
// variant.
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
type BetaWebFetchToolResultBlockCallerUnion struct {
	// Any of "direct", "code_execution_20250825", "code_execution_20260120".
	Type   string `json:"type"`
	ToolID string `json:"tool_id"`
	JSON   struct {
		Type   respjson.Field
		ToolID respjson.Field
		raw    string
	} `json:"-"`
}

// anyBetaWebFetchToolResultBlockCaller is implemented by each variant of
// [BetaWebFetchToolResultBlockCallerUnion] to add type safety for the return type
// of [BetaWebFetchToolResultBlockCallerUnion.AsAny]
type anyBetaWebFetchToolResultBlockCaller interface {
	implBetaWebFetchToolResultBlockCallerUnion()
}

func (BetaDirectCaller) implBetaWebFetchToolResultBlockCallerUnion()             {}
func (BetaServerToolCaller) implBetaWebFetchToolResultBlockCallerUnion()         {}
func (BetaServerToolCaller20260120) implBetaWebFetchToolResultBlockCallerUnion() {}

// Use the following switch statement to find the correct variant
//
//	switch variant := BetaWebFetchToolResultBlockCallerUnion.AsAny().(type) {
//	case anthropic.BetaDirectCaller:
//	case anthropic.BetaServerToolCaller:
//	case anthropic.BetaServerToolCaller20260120:
//	default:
//	  fmt.Errorf("no variant present")
//	}
func (u BetaWebFetchToolResultBlockCallerUnion) AsAny() anyBetaWebFetchToolResultBlockCaller {
	switch u.Type {
	case "direct":
		return u.AsDirect()
	case "code_execution_20250825":
		return u.AsCodeExecution20250825()
	case "code_execution_20260120":
		return u.AsCodeExecution20260120()
	}
	return nil
}

func (u BetaWebFetchToolResultBlockCallerUnion) AsDirect() (v BetaDirectCaller) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaWebFetchToolResultBlockCallerUnion) AsCodeExecution20250825() (v BetaServerToolCaller) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaWebFetchToolResultBlockCallerUnion) AsCodeExecution20260120() (v BetaServerToolCaller20260120) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u BetaWebFetchToolResultBlockCallerUnion) RawJSON() string { return u.JSON.raw }

func (r *BetaWebFetchToolResultBlockCallerUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties Content, ToolUseID, Type are required.
type BetaWebFetchToolResultBlockParam struct {
	Content   BetaWebFetchToolResultBlockParamContentUnion `json:"content,omitzero" api:"required"`
	ToolUseID string                                       `json:"tool_use_id" api:"required"`
	// Create a cache control breakpoint at this content block.
	CacheControl BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	// Tool invocation directly from the model.
	Caller BetaWebFetchToolResultBlockParamCallerUnion `json:"caller,omitzero"`
	// This field can be elided, and will marshal its zero value as
	// "web_fetch_tool_result".
	Type constant.WebFetchToolResult `json:"type" default:"web_fetch_tool_result"`
	paramObj
}

func (r BetaWebFetchToolResultBlockParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaWebFetchToolResultBlockParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaWebFetchToolResultBlockParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Only one field can be non-zero.
//
// Use [param.IsOmitted] to confirm if a field is set.
type BetaWebFetchToolResultBlockParamContentUnion struct {
	OfRequestWebFetchToolResultError *BetaWebFetchToolResultErrorBlockParam `json:",omitzero,inline"`
	OfRequestWebFetchResultBlock     *BetaWebFetchBlockParam                `json:",omitzero,inline"`
	paramUnion
}

func (u BetaWebFetchToolResultBlockParamContentUnion) MarshalJSON() ([]byte, error) {
	return param.MarshalUnion(u, u.OfRequestWebFetchToolResultError, u.OfRequestWebFetchResultBlock)
}
func (u *BetaWebFetchToolResultBlockParamContentUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, u)
}

func (u *BetaWebFetchToolResultBlockParamContentUnion) asAny() any {
	if !param.IsOmitted(u.OfRequestWebFetchToolResultError) {
		return u.OfRequestWebFetchToolResultError
	} else if !param.IsOmitted(u.OfRequestWebFetchResultBlock) {
		return u.OfRequestWebFetchResultBlock
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaWebFetchToolResultBlockParamContentUnion) GetErrorCode() *string {
	if vt := u.OfRequestWebFetchToolResultError; vt != nil {
		return (*string)(&vt.ErrorCode)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaWebFetchToolResultBlockParamContentUnion) GetContent() *BetaRequestDocumentBlockParam {
	if vt := u.OfRequestWebFetchResultBlock; vt != nil {
		return &vt.Content
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaWebFetchToolResultBlockParamContentUnion) GetURL() *string {
	if vt := u.OfRequestWebFetchResultBlock; vt != nil {
		return &vt.URL
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaWebFetchToolResultBlockParamContentUnion) GetRetrievedAt() *string {
	if vt := u.OfRequestWebFetchResultBlock; vt != nil && vt.RetrievedAt.Valid() {
		return &vt.RetrievedAt.Value
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaWebFetchToolResultBlockParamContentUnion) GetType() *string {
	if vt := u.OfRequestWebFetchToolResultError; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfRequestWebFetchResultBlock; vt != nil {
		return (*string)(&vt.Type)
	}
	return nil
}

// Only one field can be non-zero.
//
// Use [param.IsOmitted] to confirm if a field is set.
type BetaWebFetchToolResultBlockParamCallerUnion struct {
	OfDirect                *BetaDirectCallerParam             `json:",omitzero,inline"`
	OfCodeExecution20250825 *BetaServerToolCallerParam         `json:",omitzero,inline"`
	OfCodeExecution20260120 *BetaServerToolCaller20260120Param `json:",omitzero,inline"`
	paramUnion
}

func (u BetaWebFetchToolResultBlockParamCallerUnion) MarshalJSON() ([]byte, error) {
	return param.MarshalUnion(u, u.OfDirect, u.OfCodeExecution20250825, u.OfCodeExecution20260120)
}
func (u *BetaWebFetchToolResultBlockParamCallerUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, u)
}

func (u *BetaWebFetchToolResultBlockParamCallerUnion) asAny() any {
	if !param.IsOmitted(u.OfDirect) {
		return u.OfDirect
	} else if !param.IsOmitted(u.OfCodeExecution20250825) {
		return u.OfCodeExecution20250825
	} else if !param.IsOmitted(u.OfCodeExecution20260120) {
		return u.OfCodeExecution20260120
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaWebFetchToolResultBlockParamCallerUnion) GetType() *string {
	if vt := u.OfDirect; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfCodeExecution20250825; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfCodeExecution20260120; vt != nil {
		return (*string)(&vt.Type)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaWebFetchToolResultBlockParamCallerUnion) GetToolID() *string {
	if vt := u.OfCodeExecution20250825; vt != nil {
		return (*string)(&vt.ToolID)
	} else if vt := u.OfCodeExecution20260120; vt != nil {
		return (*string)(&vt.ToolID)
	}
	return nil
}

func init() {
	apijson.RegisterUnion[BetaWebFetchToolResultBlockParamCallerUnion](
		"type",
		apijson.Discriminator[BetaDirectCallerParam]("direct"),
		apijson.Discriminator[BetaServerToolCallerParam]("code_execution_20250825"),
		apijson.Discriminator[BetaServerToolCaller20260120Param]("code_execution_20260120"),
	)
}

type BetaWebFetchToolResultErrorBlock struct {
	// Any of "invalid_tool_input", "url_too_long", "url_not_allowed",
	// "url_not_in_prior_context", "url_not_accessible", "unsupported_content_type",
	// "too_many_requests", "max_uses_exceeded", "unavailable".
	ErrorCode BetaWebFetchToolResultErrorCode  `json:"error_code" api:"required"`
	Type      constant.WebFetchToolResultError `json:"type" default:"web_fetch_tool_result_error"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ErrorCode   respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaWebFetchToolResultErrorBlock) RawJSON() string { return r.JSON.raw }
func (r *BetaWebFetchToolResultErrorBlock) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties ErrorCode, Type are required.
type BetaWebFetchToolResultErrorBlockParam struct {
	// Any of "invalid_tool_input", "url_too_long", "url_not_allowed",
	// "url_not_in_prior_context", "url_not_accessible", "unsupported_content_type",
	// "too_many_requests", "max_uses_exceeded", "unavailable".
	ErrorCode BetaWebFetchToolResultErrorCode `json:"error_code,omitzero" api:"required"`
	// This field can be elided, and will marshal its zero value as
	// "web_fetch_tool_result_error".
	Type constant.WebFetchToolResultError `json:"type" default:"web_fetch_tool_result_error"`
	paramObj
}

func (r BetaWebFetchToolResultErrorBlockParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaWebFetchToolResultErrorBlockParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaWebFetchToolResultErrorBlockParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaWebFetchToolResultErrorCode string

const (
	BetaWebFetchToolResultErrorCodeInvalidToolInput       BetaWebFetchToolResultErrorCode = "invalid_tool_input"
	BetaWebFetchToolResultErrorCodeURLTooLong             BetaWebFetchToolResultErrorCode = "url_too_long"
	BetaWebFetchToolResultErrorCodeURLNotAllowed          BetaWebFetchToolResultErrorCode = "url_not_allowed"
	BetaWebFetchToolResultErrorCodeURLNotInPriorContext   BetaWebFetchToolResultErrorCode = "url_not_in_prior_context"
	BetaWebFetchToolResultErrorCodeURLNotAccessible       BetaWebFetchToolResultErrorCode = "url_not_accessible"
	BetaWebFetchToolResultErrorCodeUnsupportedContentType BetaWebFetchToolResultErrorCode = "unsupported_content_type"
	BetaWebFetchToolResultErrorCodeTooManyRequests        BetaWebFetchToolResultErrorCode = "too_many_requests"
	BetaWebFetchToolResultErrorCodeMaxUsesExceeded        BetaWebFetchToolResultErrorCode = "max_uses_exceeded"
	BetaWebFetchToolResultErrorCodeUnavailable            BetaWebFetchToolResultErrorCode = "unavailable"
)

type BetaWebSearchResultBlock struct {
	EncryptedContent string                   `json:"encrypted_content" api:"required"`
	PageAge          string                   `json:"page_age" api:"required"`
	Title            string                   `json:"title" api:"required"`
	Type             constant.WebSearchResult `json:"type" default:"web_search_result"`
	URL              string                   `json:"url" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		EncryptedContent respjson.Field
		PageAge          respjson.Field
		Title            respjson.Field
		Type             respjson.Field
		URL              respjson.Field
		ExtraFields      map[string]respjson.Field
		raw              string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaWebSearchResultBlock) RawJSON() string { return r.JSON.raw }
func (r *BetaWebSearchResultBlock) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties EncryptedContent, Title, Type, URL are required.
type BetaWebSearchResultBlockParam struct {
	EncryptedContent string            `json:"encrypted_content" api:"required"`
	Title            string            `json:"title" api:"required"`
	URL              string            `json:"url" api:"required"`
	PageAge          param.Opt[string] `json:"page_age,omitzero"`
	// This field can be elided, and will marshal its zero value as
	// "web_search_result".
	Type constant.WebSearchResult `json:"type" default:"web_search_result"`
	paramObj
}

func (r BetaWebSearchResultBlockParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaWebSearchResultBlockParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaWebSearchResultBlockParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties Name, Type are required.
type BetaWebSearchTool20250305Param struct {
	// Maximum number of times the tool can be used in the API request.
	MaxUses param.Opt[int64] `json:"max_uses,omitzero"`
	// If true, tool will not be included in initial system prompt. Only loaded when
	// returned via tool_reference from tool search.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// When true, guarantees schema validation on tool names and inputs
	Strict param.Opt[bool] `json:"strict,omitzero"`
	// If provided, only these domains will be included in results. Cannot be used
	// alongside `blocked_domains`.
	AllowedDomains []string `json:"allowed_domains,omitzero"`
	// If provided, these domains will never appear in results. Cannot be used
	// alongside `allowed_domains`.
	BlockedDomains []string `json:"blocked_domains,omitzero"`
	// Any of "direct", "code_execution_20250825", "code_execution_20260120",
	// "code_execution_20260521".
	AllowedCallers []string `json:"allowed_callers,omitzero"`
	// Create a cache control breakpoint at this content block.
	CacheControl BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	// Parameters for the user's location. Used to provide more relevant search
	// results.
	UserLocation BetaUserLocationParam `json:"user_location,omitzero"`
	// Name of the tool.
	//
	// This is how the tool will be called by the model and in `tool_use` blocks.
	//
	// This field can be elided, and will marshal its zero value as "web_search".
	Name constant.WebSearch `json:"name" default:"web_search"`
	// This field can be elided, and will marshal its zero value as
	// "web_search_20250305".
	Type constant.WebSearch20250305 `json:"type" default:"web_search_20250305"`
	paramObj
}

func (r BetaWebSearchTool20250305Param) MarshalJSON() (data []byte, err error) {
	type shadow BetaWebSearchTool20250305Param
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaWebSearchTool20250305Param) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties Name, Type are required.
type BetaWebSearchTool20260209Param struct {
	// Maximum number of times the tool can be used in the API request.
	MaxUses param.Opt[int64] `json:"max_uses,omitzero"`
	// If true, tool will not be included in initial system prompt. Only loaded when
	// returned via tool_reference from tool search.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// When true, guarantees schema validation on tool names and inputs
	Strict param.Opt[bool] `json:"strict,omitzero"`
	// If provided, only these domains will be included in results. Cannot be used
	// alongside `blocked_domains`.
	AllowedDomains []string `json:"allowed_domains,omitzero"`
	// If provided, these domains will never appear in results. Cannot be used
	// alongside `allowed_domains`.
	BlockedDomains []string `json:"blocked_domains,omitzero"`
	// Any of "direct", "code_execution_20250825", "code_execution_20260120",
	// "code_execution_20260521".
	AllowedCallers []string `json:"allowed_callers,omitzero"`
	// Create a cache control breakpoint at this content block.
	CacheControl BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	// Parameters for the user's location. Used to provide more relevant search
	// results.
	UserLocation BetaUserLocationParam `json:"user_location,omitzero"`
	// Name of the tool.
	//
	// This is how the tool will be called by the model and in `tool_use` blocks.
	//
	// This field can be elided, and will marshal its zero value as "web_search".
	Name constant.WebSearch `json:"name" default:"web_search"`
	// This field can be elided, and will marshal its zero value as
	// "web_search_20260209".
	Type constant.WebSearch20260209 `json:"type" default:"web_search_20260209"`
	paramObj
}

func (r BetaWebSearchTool20260209Param) MarshalJSON() (data []byte, err error) {
	type shadow BetaWebSearchTool20260209Param
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaWebSearchTool20260209Param) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties Name, Type are required.
type BetaWebSearchTool20260318Param struct {
	// Maximum number of times the tool can be used in the API request.
	MaxUses param.Opt[int64] `json:"max_uses,omitzero"`
	// If true, tool will not be included in initial system prompt. Only loaded when
	// returned via tool_reference from tool search.
	DeferLoading param.Opt[bool] `json:"defer_loading,omitzero"`
	// When true, guarantees schema validation on tool names and inputs
	Strict param.Opt[bool] `json:"strict,omitzero"`
	// If provided, only these domains will be included in results. Cannot be used
	// alongside `blocked_domains`.
	AllowedDomains []string `json:"allowed_domains,omitzero"`
	// If provided, these domains will never appear in results. Cannot be used
	// alongside `allowed_domains`.
	BlockedDomains []string `json:"blocked_domains,omitzero"`
	// Any of "direct", "code_execution_20250825", "code_execution_20260120",
	// "code_execution_20260521".
	AllowedCallers []string `json:"allowed_callers,omitzero"`
	// Create a cache control breakpoint at this content block.
	CacheControl BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	// How this tool's result blocks appear in the API response when the result was
	// consumed by a completed code_execution call in the same turn. 'full' returns the
	// complete content (default). 'excluded' drops the nested server_tool_use and
	// result block pair entirely. Results from direct calls, or from code_execution
	// calls that paused before completing, are always returned in full so they can be
	// sent back on the next turn.
	//
	// Any of "full", "excluded".
	ResponseInclusion BetaWebSearchTool20260318ResponseInclusion `json:"response_inclusion,omitzero"`
	// Parameters for the user's location. Used to provide more relevant search
	// results.
	UserLocation BetaUserLocationParam `json:"user_location,omitzero"`
	// Name of the tool.
	//
	// This is how the tool will be called by the model and in `tool_use` blocks.
	//
	// This field can be elided, and will marshal its zero value as "web_search".
	Name constant.WebSearch `json:"name" default:"web_search"`
	// This field can be elided, and will marshal its zero value as
	// "web_search_20260318".
	Type constant.WebSearch20260318 `json:"type" default:"web_search_20260318"`
	paramObj
}

func (r BetaWebSearchTool20260318Param) MarshalJSON() (data []byte, err error) {
	type shadow BetaWebSearchTool20260318Param
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaWebSearchTool20260318Param) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// How this tool's result blocks appear in the API response when the result was
// consumed by a completed code_execution call in the same turn. 'full' returns the
// complete content (default). 'excluded' drops the nested server_tool_use and
// result block pair entirely. Results from direct calls, or from code_execution
// calls that paused before completing, are always returned in full so they can be
// sent back on the next turn.
type BetaWebSearchTool20260318ResponseInclusion string

const (
	BetaWebSearchTool20260318ResponseInclusionFull     BetaWebSearchTool20260318ResponseInclusion = "full"
	BetaWebSearchTool20260318ResponseInclusionExcluded BetaWebSearchTool20260318ResponseInclusion = "excluded"
)

// The properties ErrorCode, Type are required.
type BetaWebSearchToolRequestErrorParam struct {
	// Any of "invalid_tool_input", "unavailable", "max_uses_exceeded",
	// "too_many_requests", "query_too_long", "request_too_large".
	ErrorCode BetaWebSearchToolResultErrorCode `json:"error_code,omitzero" api:"required"`
	// This field can be elided, and will marshal its zero value as
	// "web_search_tool_result_error".
	Type constant.WebSearchToolResultError `json:"type" default:"web_search_tool_result_error"`
	paramObj
}

func (r BetaWebSearchToolRequestErrorParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaWebSearchToolRequestErrorParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaWebSearchToolRequestErrorParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaWebSearchToolResultBlock struct {
	Content   BetaWebSearchToolResultBlockContentUnion `json:"content" api:"required"`
	ToolUseID string                                   `json:"tool_use_id" api:"required"`
	Type      constant.WebSearchToolResult             `json:"type" default:"web_search_tool_result"`
	// Tool invocation directly from the model.
	Caller BetaWebSearchToolResultBlockCallerUnion `json:"caller"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Content     respjson.Field
		ToolUseID   respjson.Field
		Type        respjson.Field
		Caller      respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaWebSearchToolResultBlock) RawJSON() string { return r.JSON.raw }
func (r *BetaWebSearchToolResultBlock) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// BetaWebSearchToolResultBlockCallerUnion contains all possible properties and
// values from [BetaDirectCaller], [BetaServerToolCaller],
// [BetaServerToolCaller20260120].
//
// Use the [BetaWebSearchToolResultBlockCallerUnion.AsAny] method to switch on the
// variant.
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
type BetaWebSearchToolResultBlockCallerUnion struct {
	// Any of "direct", "code_execution_20250825", "code_execution_20260120".
	Type   string `json:"type"`
	ToolID string `json:"tool_id"`
	JSON   struct {
		Type   respjson.Field
		ToolID respjson.Field
		raw    string
	} `json:"-"`
}

// anyBetaWebSearchToolResultBlockCaller is implemented by each variant of
// [BetaWebSearchToolResultBlockCallerUnion] to add type safety for the return type
// of [BetaWebSearchToolResultBlockCallerUnion.AsAny]
type anyBetaWebSearchToolResultBlockCaller interface {
	implBetaWebSearchToolResultBlockCallerUnion()
}

func (BetaDirectCaller) implBetaWebSearchToolResultBlockCallerUnion()             {}
func (BetaServerToolCaller) implBetaWebSearchToolResultBlockCallerUnion()         {}
func (BetaServerToolCaller20260120) implBetaWebSearchToolResultBlockCallerUnion() {}

// Use the following switch statement to find the correct variant
//
//	switch variant := BetaWebSearchToolResultBlockCallerUnion.AsAny().(type) {
//	case anthropic.BetaDirectCaller:
//	case anthropic.BetaServerToolCaller:
//	case anthropic.BetaServerToolCaller20260120:
//	default:
//	  fmt.Errorf("no variant present")
//	}
func (u BetaWebSearchToolResultBlockCallerUnion) AsAny() anyBetaWebSearchToolResultBlockCaller {
	switch u.Type {
	case "direct":
		return u.AsDirect()
	case "code_execution_20250825":
		return u.AsCodeExecution20250825()
	case "code_execution_20260120":
		return u.AsCodeExecution20260120()
	}
	return nil
}

func (u BetaWebSearchToolResultBlockCallerUnion) AsDirect() (v BetaDirectCaller) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaWebSearchToolResultBlockCallerUnion) AsCodeExecution20250825() (v BetaServerToolCaller) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaWebSearchToolResultBlockCallerUnion) AsCodeExecution20260120() (v BetaServerToolCaller20260120) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u BetaWebSearchToolResultBlockCallerUnion) RawJSON() string { return u.JSON.raw }

func (r *BetaWebSearchToolResultBlockCallerUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// BetaWebSearchToolResultBlockContentUnion contains all possible properties and
// values from [BetaWebSearchToolResultError], [[]BetaWebSearchResultBlock].
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
//
// If the underlying value is not a json object, one of the following properties
// will be valid: OfBetaWebSearchResultBlockArray]
type BetaWebSearchToolResultBlockContentUnion struct {
	// This field will be present if the value is a [[]BetaWebSearchResultBlock]
	// instead of an object.
	OfBetaWebSearchResultBlockArray []BetaWebSearchResultBlock `json:",inline"`
	// This field is from variant [BetaWebSearchToolResultError].
	ErrorCode BetaWebSearchToolResultErrorCode `json:"error_code"`
	// This field is from variant [BetaWebSearchToolResultError].
	Type constant.WebSearchToolResultError `json:"type"`
	JSON struct {
		OfBetaWebSearchResultBlockArray respjson.Field
		ErrorCode                       respjson.Field
		Type                            respjson.Field
		raw                             string
	} `json:"-"`
}

func (u BetaWebSearchToolResultBlockContentUnion) AsResponseWebSearchToolResultError() (v BetaWebSearchToolResultError) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u BetaWebSearchToolResultBlockContentUnion) AsBetaWebSearchResultBlockArray() (v []BetaWebSearchResultBlock) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u BetaWebSearchToolResultBlockContentUnion) RawJSON() string { return u.JSON.raw }

func (r *BetaWebSearchToolResultBlockContentUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// The properties Content, ToolUseID, Type are required.
type BetaWebSearchToolResultBlockParam struct {
	Content   BetaWebSearchToolResultBlockParamContentUnion `json:"content,omitzero" api:"required"`
	ToolUseID string                                        `json:"tool_use_id" api:"required"`
	// Create a cache control breakpoint at this content block.
	CacheControl BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	// Tool invocation directly from the model.
	Caller BetaWebSearchToolResultBlockParamCallerUnion `json:"caller,omitzero"`
	// This field can be elided, and will marshal its zero value as
	// "web_search_tool_result".
	Type constant.WebSearchToolResult `json:"type" default:"web_search_tool_result"`
	paramObj
}

func (r BetaWebSearchToolResultBlockParam) MarshalJSON() (data []byte, err error) {
	type shadow BetaWebSearchToolResultBlockParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaWebSearchToolResultBlockParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Only one field can be non-zero.
//
// Use [param.IsOmitted] to confirm if a field is set.
type BetaWebSearchToolResultBlockParamCallerUnion struct {
	OfDirect                *BetaDirectCallerParam             `json:",omitzero,inline"`
	OfCodeExecution20250825 *BetaServerToolCallerParam         `json:",omitzero,inline"`
	OfCodeExecution20260120 *BetaServerToolCaller20260120Param `json:",omitzero,inline"`
	paramUnion
}

func (u BetaWebSearchToolResultBlockParamCallerUnion) MarshalJSON() ([]byte, error) {
	return param.MarshalUnion(u, u.OfDirect, u.OfCodeExecution20250825, u.OfCodeExecution20260120)
}
func (u *BetaWebSearchToolResultBlockParamCallerUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, u)
}

func (u *BetaWebSearchToolResultBlockParamCallerUnion) asAny() any {
	if !param.IsOmitted(u.OfDirect) {
		return u.OfDirect
	} else if !param.IsOmitted(u.OfCodeExecution20250825) {
		return u.OfCodeExecution20250825
	} else if !param.IsOmitted(u.OfCodeExecution20260120) {
		return u.OfCodeExecution20260120
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaWebSearchToolResultBlockParamCallerUnion) GetType() *string {
	if vt := u.OfDirect; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfCodeExecution20250825; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfCodeExecution20260120; vt != nil {
		return (*string)(&vt.Type)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaWebSearchToolResultBlockParamCallerUnion) GetToolID() *string {
	if vt := u.OfCodeExecution20250825; vt != nil {
		return (*string)(&vt.ToolID)
	} else if vt := u.OfCodeExecution20260120; vt != nil {
		return (*string)(&vt.ToolID)
	}
	return nil
}

func init() {
	apijson.RegisterUnion[BetaWebSearchToolResultBlockParamCallerUnion](
		"type",
		apijson.Discriminator[BetaDirectCallerParam]("direct"),
		apijson.Discriminator[BetaServerToolCallerParam]("code_execution_20250825"),
		apijson.Discriminator[BetaServerToolCaller20260120Param]("code_execution_20260120"),
	)
}

func BetaNewWebSearchToolRequestError(errorCode BetaWebSearchToolResultErrorCode) BetaWebSearchToolResultBlockParamContentUnion {
	var variant BetaWebSearchToolRequestErrorParam
	variant.ErrorCode = errorCode
	return BetaWebSearchToolResultBlockParamContentUnion{OfError: &variant}
}

// Only one field can be non-zero.
//
// Use [param.IsOmitted] to confirm if a field is set.
type BetaWebSearchToolResultBlockParamContentUnion struct {
	OfResultBlock []BetaWebSearchResultBlockParam     `json:",omitzero,inline"`
	OfError       *BetaWebSearchToolRequestErrorParam `json:",omitzero,inline"`
	paramUnion
}

func (u BetaWebSearchToolResultBlockParamContentUnion) MarshalJSON() ([]byte, error) {
	return param.MarshalUnion(u, u.OfResultBlock, u.OfError)
}
func (u *BetaWebSearchToolResultBlockParamContentUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, u)
}

func (u *BetaWebSearchToolResultBlockParamContentUnion) asAny() any {
	if !param.IsOmitted(u.OfResultBlock) {
		return &u.OfResultBlock
	} else if !param.IsOmitted(u.OfError) {
		return u.OfError
	}
	return nil
}

type BetaWebSearchToolResultError struct {
	// Any of "invalid_tool_input", "unavailable", "max_uses_exceeded",
	// "too_many_requests", "query_too_long", "request_too_large".
	ErrorCode BetaWebSearchToolResultErrorCode  `json:"error_code" api:"required"`
	Type      constant.WebSearchToolResultError `json:"type" default:"web_search_tool_result_error"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ErrorCode   respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r BetaWebSearchToolResultError) RawJSON() string { return r.JSON.raw }
func (r *BetaWebSearchToolResultError) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type BetaWebSearchToolResultErrorCode string

const (
	BetaWebSearchToolResultErrorCodeInvalidToolInput BetaWebSearchToolResultErrorCode = "invalid_tool_input"
	BetaWebSearchToolResultErrorCodeUnavailable      BetaWebSearchToolResultErrorCode = "unavailable"
	BetaWebSearchToolResultErrorCodeMaxUsesExceeded  BetaWebSearchToolResultErrorCode = "max_uses_exceeded"
	BetaWebSearchToolResultErrorCodeTooManyRequests  BetaWebSearchToolResultErrorCode = "too_many_requests"
	BetaWebSearchToolResultErrorCodeQueryTooLong     BetaWebSearchToolResultErrorCode = "query_too_long"
	BetaWebSearchToolResultErrorCodeRequestTooLarge  BetaWebSearchToolResultErrorCode = "request_too_large"
)

type BetaMessageNewParams struct {
	// The maximum number of tokens to generate before stopping.
	//
	// Note that our models may stop _before_ reaching this maximum. This parameter
	// only specifies the absolute maximum number of tokens to generate.
	//
	// Set to `0` to populate the
	// [prompt cache](https://platform.claude.com/docs/en/build-with-claude/prompt-caching#pre-warming-the-cache)
	// without generating a response.
	//
	// Different models have different maximum values for this parameter. See
	// [models](https://platform.claude.com/docs/en/about-claude/models/overview) for
	// details.
	MaxTokens int64 `json:"max_tokens" api:"required"`
	// Input messages.
	//
	// Our models are trained to operate on alternating `user` and `assistant`
	// conversational turns. When creating a new `Message`, you specify the prior
	// conversational turns with the `messages` parameter, and the model then generates
	// the next `Message` in the conversation. Consecutive `user` or `assistant` turns
	// in your request will be combined into a single turn.
	//
	// Each input message must be an object with a `role` and `content`. You can
	// specify a single `user`-role message, or you can include multiple `user` and
	// `assistant` messages.
	//
	// If the final message uses the `assistant` role, the response content will
	// continue immediately from the content in that message. This can be used to
	// constrain part of the model's response.
	//
	// Example with a single `user` message:
	//
	// ```json
	// [{ "role": "user", "content": "Hello, Claude" }]
	// ```
	//
	// Example with multiple conversational turns:
	//
	// ```json
	// [
	//
	//	{ "role": "user", "content": "Hello there." },
	//	{ "role": "assistant", "content": "Hi, I'm Claude. How can I help you?" },
	//	{ "role": "user", "content": "Can you explain LLMs in plain English?" }
	//
	// ]
	// ```
	//
	// Example with a partially-filled response from Claude:
	//
	// ```json
	// [
	//
	//	{
	//	  "role": "user",
	//	  "content": "What's the Greek name for Sun? (A) Sol (B) Helios (C) Sun"
	//	},
	//	{ "role": "assistant", "content": "The best answer is (" }
	//
	// ]
	// ```
	//
	// Each input message `content` may be either a single `string` or an array of
	// content blocks, where each block has a specific `type`. Using a `string` for
	// `content` is shorthand for an array of one content block of type `"text"`. The
	// following input messages are equivalent:
	//
	// ```json
	// { "role": "user", "content": "Hello, Claude" }
	// ```
	//
	// ```json
	// { "role": "user", "content": [{ "type": "text", "text": "Hello, Claude" }] }
	// ```
	//
	// See
	// [input examples](https://platform.claude.com/docs/en/build-with-claude/working-with-messages).
	//
	// Note that if you want to include a
	// [system prompt](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/claude-prompting-best-practices#give-claude-a-role),
	// you can use the top-level `system` parameter — there is no `"system"` role for
	// input messages in the Messages API.
	//
	// There is a limit of 100,000 messages in a single request.
	Messages []BetaMessageParam `json:"messages,omitzero" api:"required"`
	// The model that will complete your prompt.
	//
	// See [models](https://docs.anthropic.com/en/docs/models-overview) for additional
	// details and options.
	Model Model `json:"model,omitzero" api:"required"`
	// Specifies the geographic region for inference processing. If not specified, the
	// workspace's `default_inference_geo` is used.
	InferenceGeo param.Opt[string] `json:"inference_geo,omitzero"`
	// Amount of randomness injected into the response.
	//
	// Defaults to `1.0`. Ranges from `0.0` to `1.0`. Use `temperature` closer to `0.0`
	// for analytical / multiple choice, and closer to `1.0` for creative and
	// generative tasks.
	//
	// Note that even with `temperature` of `0.0`, the results will not be fully
	// deterministic.
	Temperature param.Opt[float64] `json:"temperature,omitzero"`
	// Only sample from the top K options for each subsequent token.
	//
	// Used to remove "long tail" low probability responses.
	// [Learn more technical details here](https://towardsdatascience.com/how-to-sample-from-language-models-682bceb97277).
	//
	// Recommended for advanced use cases only.
	TopK param.Opt[int64] `json:"top_k,omitzero"`
	// Use nucleus sampling.
	//
	// In nucleus sampling, we compute the cumulative distribution over all the options
	// for each subsequent token in decreasing probability order and cut it off once it
	// reaches a particular probability specified by `top_p`.
	//
	// Recommended for advanced use cases only.
	TopP param.Opt[float64] `json:"top_p,omitzero"`
	// The user profile ID to attribute this request to. Use when acting on behalf of a
	// party other than your organization. Requires the `user-profiles` beta header.
	UserProfileID param.Opt[string] `header:"anthropic-user-profile-id,omitzero" json:"-"`
	WorkspaceID   param.Opt[string] `header:"anthropic-workspace-id,omitzero" json:"-"`
	// Container identifier for reuse across requests.
	Container BetaMessageNewParamsContainerUnion `json:"container,omitzero"`
	// The `fallback_credit_token` from a prior refusal's `stop_details`.
	//
	// When a preceding request was refused and returned a `fallback_credit_token`,
	// pass that code here on the retry to have the retry's cache-creation tokens for
	// the prefix that was warm on the refused model billed at the cache-read rate.
	// Must be redeemed by the same organization and workspace, with the same request
	// body (optionally extended by one appended `assistant` message whose content is
	// the partial text — with any trailing whitespace stripped from the final text
	// block — and paired server-tool blocks streamed before the refusal; the
	// appended-assistant form is not available for requests with `output_format` set
	// or forced `tool_choice`), on an eligible fallback model, on the same platform,
	// and within 5 minutes of the refusal; a mismatch is a 400. A token minted
	// mid-server-tool-loop whose partial content was continuable may only be redeemed
	// with the appended-assistant form — if an exact-body retry is rejected with a 400
	// saying the token must be redeemed by continuing the partial response, retry with
	// the appended-assistant form instead.
	//
	// When the appended-assistant form is used on a model that otherwise disallows
	// assistant-turn prefill, this token also authorizes that one prefill.
	FallbackCreditToken BetaMessageNewParamsFallbackCreditTokenUnion `json:"fallback_credit_token,omitzero"`
	// Opt-in server-side retry on one or more substitute models when the requested
	// model declines for policy reasons. Tried in order: if the first entry also
	// declines, the second is tried, and so on. The string "default" requests the
	// requested model's server-defined default fallback configuration.
	Fallbacks BetaFallbacksParamUnion `json:"fallbacks,omitzero"`
	// Inference speed mode. `fast` provides significantly faster output token
	// generation at premium pricing. Not all models support `fast`; invalid
	// combinations are rejected at create time.
	//
	// Any of "standard", "fast".
	Speed BetaMessageNewParamsSpeed `json:"speed,omitzero"`
	// Top-level cache control automatically applies a cache_control marker to the last
	// cacheable block in the request.
	CacheControl BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	// Context management configuration.
	//
	// This allows you to control how Claude manages context across multiple requests,
	// such as whether to clear function results or not.
	ContextManagement BetaContextManagementConfigParam `json:"context_management,omitzero"`
	// Request-level diagnostics. Currently carries the previous response id for
	// prompt-cache divergence reporting.
	Diagnostics BetaDiagnosticsParam `json:"diagnostics,omitzero"`
	// MCP servers to be utilized in this request
	MCPServers []BetaRequestMCPServerURLDefinitionParam `json:"mcp_servers,omitzero"`
	// An object describing metadata about the request.
	Metadata BetaMetadataParam `json:"metadata,omitzero"`
	// Configuration options for the model's output, such as the output format.
	OutputConfig BetaOutputConfigParam `json:"output_config,omitzero"`
	// Deprecated: Use `output_config.format` instead. See
	// [structured outputs](https://platform.claude.com/docs/en/build-with-claude/structured-outputs)
	//
	// A schema to specify Claude's output format in responses. This parameter will be
	// removed in a future release.
	OutputFormat BetaJSONOutputFormatParam `json:"output_format,omitzero"`
	// Determines whether to use priority capacity (if available) or standard capacity
	// for this request.
	//
	// Anthropic offers different levels of service for your API requests. See
	// [service-tiers](https://platform.claude.com/docs/en/api/service-tiers) for
	// details.
	//
	// Any of "auto", "standard_only".
	ServiceTier BetaMessageNewParamsServiceTier `json:"service_tier,omitzero"`
	// Custom text sequences that will cause the model to stop generating.
	//
	// Our models will normally stop when they have naturally completed their turn,
	// which will result in a response `stop_reason` of `"end_turn"`.
	//
	// If you want the model to stop generating when it encounters custom strings of
	// text, you can use the `stop_sequences` parameter. If the model encounters one of
	// the custom sequences, the response `stop_reason` value will be `"stop_sequence"`
	// and the response `stop_sequence` value will contain the matched stop sequence.
	StopSequences []string `json:"stop_sequences,omitzero"`
	// System prompt.
	//
	// A system prompt is a way of providing context and instructions to Claude, such
	// as specifying a particular goal or role. See our
	// [guide to system prompts](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/claude-prompting-best-practices#give-claude-a-role).
	System []BetaTextBlockParam `json:"system,omitzero"`
	// Configuration for enabling Claude's extended thinking.
	//
	// When enabled, responses include `thinking` content blocks showing Claude's
	// thinking process before the final answer. Requires a minimum budget of 1,024
	// tokens and counts towards your `max_tokens` limit.
	//
	// See
	// [extended thinking](https://platform.claude.com/docs/en/build-with-claude/extended-thinking)
	// for details.
	Thinking BetaThinkingConfigParamUnion `json:"thinking,omitzero"`
	// How the model should use the provided tools. The model can use a specific tool,
	// any available tool, decide by itself, or not use tools at all.
	ToolChoice BetaToolChoiceUnionParam `json:"tool_choice,omitzero"`
	// Definitions of tools that the model may use.
	//
	// If you include `tools` in your API request, the model may return `tool_use`
	// content blocks that represent the model's use of those tools. You can then run
	// those tools using the tool input generated by the model and then optionally
	// return results back to the model using `tool_result` content blocks.
	//
	// There are two types of tools: **client tools** and **server tools**. The
	// behavior described below applies to client tools. For
	// [server tools](https://platform.claude.com/docs/en/agents-and-tools/tool-use/server-tools),
	// see their individual documentation as each has its own behavior (e.g., the
	// [web search tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/web-search-tool)).
	//
	// Each tool definition includes:
	//
	//   - `name`: Name of the tool.
	//   - `description`: Optional, but strongly-recommended description of the tool.
	//   - `input_schema`: [JSON schema](https://json-schema.org/draft/2020-12) for the
	//     tool `input` shape that the model will produce in `tool_use` output content
	//     blocks.
	//
	// For example, if you defined `tools` as:
	//
	// ```json
	// [
	//
	//	{
	//	  "name": "get_stock_price",
	//	  "description": "Get the current stock price for a given ticker symbol.",
	//	  "input_schema": {
	//	    "type": "object",
	//	    "properties": {
	//	      "ticker": {
	//	        "type": "string",
	//	        "description": "The stock ticker symbol, e.g. AAPL for Apple Inc."
	//	      }
	//	    },
	//	    "required": ["ticker"]
	//	  }
	//	}
	//
	// ]
	// ```
	//
	// And then asked the model "What's the S&P 500 at today?", the model might produce
	// `tool_use` content blocks in the response like this:
	//
	// ```json
	// [
	//
	//	{
	//	  "type": "tool_use",
	//	  "id": "toolu_01D7FLrfh4GYq7yT1ULFeyMV",
	//	  "name": "get_stock_price",
	//	  "input": { "ticker": "^GSPC" }
	//	}
	//
	// ]
	// ```
	//
	// You might then run your `get_stock_price` tool with `{"ticker": "^GSPC"}` as an
	// input, and return the following back to the model in a subsequent `user`
	// message:
	//
	// ```json
	// [
	//
	//	{
	//	  "type": "tool_result",
	//	  "tool_use_id": "toolu_01D7FLrfh4GYq7yT1ULFeyMV",
	//	  "content": "259.75 USD"
	//	}
	//
	// ]
	// ```
	//
	// Tools can be used for workflows that include running client-side tools and
	// functions, or more generally whenever you want the model to produce a particular
	// JSON structure of output.
	//
	// See our
	// [guide](https://platform.claude.com/docs/en/agents-and-tools/tool-use/overview)
	// for more details.
	Tools []BetaToolUnionParam `json:"tools,omitzero"`
	// Optional header to specify the beta version(s) you want to use.
	Betas []AnthropicBeta `header:"anthropic-beta,omitzero" json:"-"`
	paramObj
}

func (r BetaMessageNewParams) MarshalJSON() (data []byte, err error) {
	type shadow BetaMessageNewParams
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaMessageNewParams) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Only one field can be non-zero.
//
// Use [param.IsOmitted] to confirm if a field is set.
type BetaMessageNewParamsContainerUnion struct {
	OfContainers *BetaContainerParams `json:",omitzero,inline"`
	OfString     param.Opt[string]    `json:",omitzero,inline"`
	paramUnion
}

func (u BetaMessageNewParamsContainerUnion) MarshalJSON() ([]byte, error) {
	return param.MarshalUnion(u, u.OfContainers, u.OfString)
}
func (u *BetaMessageNewParamsContainerUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, u)
}

func (u *BetaMessageNewParamsContainerUnion) asAny() any {
	if !param.IsOmitted(u.OfContainers) {
		return u.OfContainers
	} else if !param.IsOmitted(u.OfString) {
		return &u.OfString.Value
	}
	return nil
}

// Only one field can be non-zero.
//
// Use [param.IsOmitted] to confirm if a field is set.
type BetaMessageNewParamsFallbackCreditTokenUnion struct {
	OfString              param.Opt[string]             `json:",omitzero,inline"`
	OfFallbackCreditToken *BetaFallbackCreditTokenParam `json:",omitzero,inline"`
	paramUnion
}

func (u BetaMessageNewParamsFallbackCreditTokenUnion) MarshalJSON() ([]byte, error) {
	return param.MarshalUnion(u, u.OfString, u.OfFallbackCreditToken)
}
func (u *BetaMessageNewParamsFallbackCreditTokenUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, u)
}

func (u *BetaMessageNewParamsFallbackCreditTokenUnion) asAny() any {
	if !param.IsOmitted(u.OfString) {
		return &u.OfString.Value
	} else if !param.IsOmitted(u.OfFallbackCreditToken) {
		return u.OfFallbackCreditToken
	}
	return nil
}

// Determines whether to use priority capacity (if available) or standard capacity
// for this request.
//
// Anthropic offers different levels of service for your API requests. See
// [service-tiers](https://platform.claude.com/docs/en/api/service-tiers) for
// details.
type BetaMessageNewParamsServiceTier string

const (
	BetaMessageNewParamsServiceTierAuto         BetaMessageNewParamsServiceTier = "auto"
	BetaMessageNewParamsServiceTierStandardOnly BetaMessageNewParamsServiceTier = "standard_only"
)

// Inference speed mode. `fast` provides significantly faster output token
// generation at premium pricing. Not all models support `fast`; invalid
// combinations are rejected at create time.
type BetaMessageNewParamsSpeed string

const (
	BetaMessageNewParamsSpeedStandard BetaMessageNewParamsSpeed = "standard"
	BetaMessageNewParamsSpeedFast     BetaMessageNewParamsSpeed = "fast"
)

type BetaMessageCountTokensParams struct {
	// Input messages.
	//
	// Our models are trained to operate on alternating `user` and `assistant`
	// conversational turns. When creating a new `Message`, you specify the prior
	// conversational turns with the `messages` parameter, and the model then generates
	// the next `Message` in the conversation. Consecutive `user` or `assistant` turns
	// in your request will be combined into a single turn.
	//
	// Each input message must be an object with a `role` and `content`. You can
	// specify a single `user`-role message, or you can include multiple `user` and
	// `assistant` messages.
	//
	// If the final message uses the `assistant` role, the response content will
	// continue immediately from the content in that message. This can be used to
	// constrain part of the model's response.
	//
	// Example with a single `user` message:
	//
	// ```json
	// [{ "role": "user", "content": "Hello, Claude" }]
	// ```
	//
	// Example with multiple conversational turns:
	//
	// ```json
	// [
	//
	//	{ "role": "user", "content": "Hello there." },
	//	{ "role": "assistant", "content": "Hi, I'm Claude. How can I help you?" },
	//	{ "role": "user", "content": "Can you explain LLMs in plain English?" }
	//
	// ]
	// ```
	//
	// Example with a partially-filled response from Claude:
	//
	// ```json
	// [
	//
	//	{
	//	  "role": "user",
	//	  "content": "What's the Greek name for Sun? (A) Sol (B) Helios (C) Sun"
	//	},
	//	{ "role": "assistant", "content": "The best answer is (" }
	//
	// ]
	// ```
	//
	// Each input message `content` may be either a single `string` or an array of
	// content blocks, where each block has a specific `type`. Using a `string` for
	// `content` is shorthand for an array of one content block of type `"text"`. The
	// following input messages are equivalent:
	//
	// ```json
	// { "role": "user", "content": "Hello, Claude" }
	// ```
	//
	// ```json
	// { "role": "user", "content": [{ "type": "text", "text": "Hello, Claude" }] }
	// ```
	//
	// See
	// [input examples](https://platform.claude.com/docs/en/build-with-claude/working-with-messages).
	//
	// Note that if you want to include a
	// [system prompt](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/claude-prompting-best-practices#give-claude-a-role),
	// you can use the top-level `system` parameter — there is no `"system"` role for
	// input messages in the Messages API.
	//
	// There is a limit of 100,000 messages in a single request.
	Messages []BetaMessageParam `json:"messages,omitzero" api:"required"`
	// The model that will complete your prompt.
	//
	// See [models](https://docs.anthropic.com/en/docs/models-overview) for additional
	// details and options.
	Model Model `json:"model,omitzero" api:"required"`
	// The user profile ID to attribute this request to. Use when acting on behalf of a
	// party other than your organization. Requires the `user-profiles` beta header.
	UserProfileID param.Opt[string] `header:"anthropic-user-profile-id,omitzero" json:"-"`
	WorkspaceID   param.Opt[string] `header:"anthropic-workspace-id,omitzero" json:"-"`
	// Inference speed mode. `fast` provides significantly faster output token
	// generation at premium pricing. Not all models support `fast`; invalid
	// combinations are rejected at create time.
	//
	// Any of "standard", "fast".
	Speed BetaMessageCountTokensParamsSpeed `json:"speed,omitzero"`
	// Top-level cache control automatically applies a cache_control marker to the last
	// cacheable block in the request.
	CacheControl BetaCacheControlEphemeralParam `json:"cache_control,omitzero"`
	// Context management configuration.
	//
	// This allows you to control how Claude manages context across multiple requests,
	// such as whether to clear function results or not.
	ContextManagement BetaContextManagementConfigParam `json:"context_management,omitzero"`
	// MCP servers to be utilized in this request
	MCPServers []BetaRequestMCPServerURLDefinitionParam `json:"mcp_servers,omitzero"`
	// Configuration options for the model's output, such as the output format.
	OutputConfig BetaOutputConfigParam `json:"output_config,omitzero"`
	// Deprecated: Use `output_config.format` instead. See
	// [structured outputs](https://platform.claude.com/docs/en/build-with-claude/structured-outputs)
	//
	// A schema to specify Claude's output format in responses. This parameter will be
	// removed in a future release.
	OutputFormat BetaJSONOutputFormatParam `json:"output_format,omitzero"`
	// System prompt.
	//
	// A system prompt is a way of providing context and instructions to Claude, such
	// as specifying a particular goal or role. See our
	// [guide to system prompts](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/claude-prompting-best-practices#give-claude-a-role).
	System BetaMessageCountTokensParamsSystemUnion `json:"system,omitzero"`
	// Configuration for enabling Claude's extended thinking.
	//
	// When enabled, responses include `thinking` content blocks showing Claude's
	// thinking process before the final answer. Requires a minimum budget of 1,024
	// tokens and counts towards your `max_tokens` limit.
	//
	// See
	// [extended thinking](https://platform.claude.com/docs/en/build-with-claude/extended-thinking)
	// for details.
	Thinking BetaThinkingConfigParamUnion `json:"thinking,omitzero"`
	// How the model should use the provided tools. The model can use a specific tool,
	// any available tool, decide by itself, or not use tools at all.
	ToolChoice BetaToolChoiceUnionParam `json:"tool_choice,omitzero"`
	// Definitions of tools that the model may use.
	//
	// If you include `tools` in your API request, the model may return `tool_use`
	// content blocks that represent the model's use of those tools. You can then run
	// those tools using the tool input generated by the model and then optionally
	// return results back to the model using `tool_result` content blocks.
	//
	// There are two types of tools: **client tools** and **server tools**. The
	// behavior described below applies to client tools. For
	// [server tools](https://platform.claude.com/docs/en/agents-and-tools/tool-use/server-tools),
	// see their individual documentation as each has its own behavior (e.g., the
	// [web search tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/web-search-tool)).
	//
	// Each tool definition includes:
	//
	//   - `name`: Name of the tool.
	//   - `description`: Optional, but strongly-recommended description of the tool.
	//   - `input_schema`: [JSON schema](https://json-schema.org/draft/2020-12) for the
	//     tool `input` shape that the model will produce in `tool_use` output content
	//     blocks.
	//
	// For example, if you defined `tools` as:
	//
	// ```json
	// [
	//
	//	{
	//	  "name": "get_stock_price",
	//	  "description": "Get the current stock price for a given ticker symbol.",
	//	  "input_schema": {
	//	    "type": "object",
	//	    "properties": {
	//	      "ticker": {
	//	        "type": "string",
	//	        "description": "The stock ticker symbol, e.g. AAPL for Apple Inc."
	//	      }
	//	    },
	//	    "required": ["ticker"]
	//	  }
	//	}
	//
	// ]
	// ```
	//
	// And then asked the model "What's the S&P 500 at today?", the model might produce
	// `tool_use` content blocks in the response like this:
	//
	// ```json
	// [
	//
	//	{
	//	  "type": "tool_use",
	//	  "id": "toolu_01D7FLrfh4GYq7yT1ULFeyMV",
	//	  "name": "get_stock_price",
	//	  "input": { "ticker": "^GSPC" }
	//	}
	//
	// ]
	// ```
	//
	// You might then run your `get_stock_price` tool with `{"ticker": "^GSPC"}` as an
	// input, and return the following back to the model in a subsequent `user`
	// message:
	//
	// ```json
	// [
	//
	//	{
	//	  "type": "tool_result",
	//	  "tool_use_id": "toolu_01D7FLrfh4GYq7yT1ULFeyMV",
	//	  "content": "259.75 USD"
	//	}
	//
	// ]
	// ```
	//
	// Tools can be used for workflows that include running client-side tools and
	// functions, or more generally whenever you want the model to produce a particular
	// JSON structure of output.
	//
	// See our
	// [guide](https://platform.claude.com/docs/en/agents-and-tools/tool-use/overview)
	// for more details.
	Tools []BetaMessageCountTokensParamsToolUnion `json:"tools,omitzero"`
	// Optional header to specify the beta version(s) you want to use.
	Betas []AnthropicBeta `header:"anthropic-beta,omitzero" json:"-"`
	paramObj
}

func (r BetaMessageCountTokensParams) MarshalJSON() (data []byte, err error) {
	type shadow BetaMessageCountTokensParams
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *BetaMessageCountTokensParams) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Inference speed mode. `fast` provides significantly faster output token
// generation at premium pricing. Not all models support `fast`; invalid
// combinations are rejected at create time.
type BetaMessageCountTokensParamsSpeed string

const (
	BetaMessageCountTokensParamsSpeedStandard BetaMessageCountTokensParamsSpeed = "standard"
	BetaMessageCountTokensParamsSpeedFast     BetaMessageCountTokensParamsSpeed = "fast"
)

// Only one field can be non-zero.
//
// Use [param.IsOmitted] to confirm if a field is set.
type BetaMessageCountTokensParamsSystemUnion struct {
	OfString             param.Opt[string]    `json:",omitzero,inline"`
	OfBetaTextBlockArray []BetaTextBlockParam `json:",omitzero,inline"`
	paramUnion
}

func (u BetaMessageCountTokensParamsSystemUnion) MarshalJSON() ([]byte, error) {
	return param.MarshalUnion(u, u.OfString, u.OfBetaTextBlockArray)
}
func (u *BetaMessageCountTokensParamsSystemUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, u)
}

func (u *BetaMessageCountTokensParamsSystemUnion) asAny() any {
	if !param.IsOmitted(u.OfString) {
		return &u.OfString.Value
	} else if !param.IsOmitted(u.OfBetaTextBlockArray) {
		return &u.OfBetaTextBlockArray
	}
	return nil
}

// Only one field can be non-zero.
//
// Use [param.IsOmitted] to confirm if a field is set.
type BetaMessageCountTokensParamsToolUnion struct {
	OfTool                        *BetaToolParam                        `json:",omitzero,inline"`
	OfBashTool20241022            *BetaToolBash20241022Param            `json:",omitzero,inline"`
	OfBashTool20250124            *BetaToolBash20250124Param            `json:",omitzero,inline"`
	OfCodeExecutionTool20250522   *BetaCodeExecutionTool20250522Param   `json:",omitzero,inline"`
	OfCodeExecutionTool20250825   *BetaCodeExecutionTool20250825Param   `json:",omitzero,inline"`
	OfCodeExecutionTool20260120   *BetaCodeExecutionTool20260120Param   `json:",omitzero,inline"`
	OfCodeExecutionTool20260521   *BetaCodeExecutionTool20260521Param   `json:",omitzero,inline"`
	OfBrowserToolset20260801      *BetaBrowserToolset20260801Param      `json:",omitzero,inline"`
	OfComputerUseTool20241022     *BetaToolComputerUse20241022Param     `json:",omitzero,inline"`
	OfMemoryTool20250818          *BetaMemoryTool20250818Param          `json:",omitzero,inline"`
	OfComputerUseTool20250124     *BetaToolComputerUse20250124Param     `json:",omitzero,inline"`
	OfTextEditor20241022          *BetaToolTextEditor20241022Param      `json:",omitzero,inline"`
	OfComputerUseTool20251124     *BetaToolComputerUse20251124Param     `json:",omitzero,inline"`
	OfComputerToolset20260801     *BetaComputerToolset20260801Param     `json:",omitzero,inline"`
	OfTextEditor20250124          *BetaToolTextEditor20250124Param      `json:",omitzero,inline"`
	OfTextEditor20250429          *BetaToolTextEditor20250429Param      `json:",omitzero,inline"`
	OfTextEditor20250728          *BetaToolTextEditor20250728Param      `json:",omitzero,inline"`
	OfWebSearchTool20250305       *BetaWebSearchTool20250305Param       `json:",omitzero,inline"`
	OfWebFetchTool20250910        *BetaWebFetchTool20250910Param        `json:",omitzero,inline"`
	OfWebSearchTool20260209       *BetaWebSearchTool20260209Param       `json:",omitzero,inline"`
	OfWebFetchTool20260209        *BetaWebFetchTool20260209Param        `json:",omitzero,inline"`
	OfWebFetchTool20260309        *BetaWebFetchTool20260309Param        `json:",omitzero,inline"`
	OfWebSearchTool20260318       *BetaWebSearchTool20260318Param       `json:",omitzero,inline"`
	OfWebFetchTool20260318        *BetaWebFetchTool20260318Param        `json:",omitzero,inline"`
	OfAdvisorTool20260301         *BetaAdvisorTool20260301Param         `json:",omitzero,inline"`
	OfToolSearchToolBm25_20251119 *BetaToolSearchToolBm25_20251119Param `json:",omitzero,inline"`
	OfToolSearchToolRegex20251119 *BetaToolSearchToolRegex20251119Param `json:",omitzero,inline"`
	OfMCPToolset                  *BetaMCPToolsetParam                  `json:",omitzero,inline"`
	paramUnion
}

func (u BetaMessageCountTokensParamsToolUnion) MarshalJSON() ([]byte, error) {
	return param.MarshalUnion(u, u.OfTool,
		u.OfBashTool20241022,
		u.OfBashTool20250124,
		u.OfCodeExecutionTool20250522,
		u.OfCodeExecutionTool20250825,
		u.OfCodeExecutionTool20260120,
		u.OfCodeExecutionTool20260521,
		u.OfBrowserToolset20260801,
		u.OfComputerUseTool20241022,
		u.OfMemoryTool20250818,
		u.OfComputerUseTool20250124,
		u.OfTextEditor20241022,
		u.OfComputerUseTool20251124,
		u.OfComputerToolset20260801,
		u.OfTextEditor20250124,
		u.OfTextEditor20250429,
		u.OfTextEditor20250728,
		u.OfWebSearchTool20250305,
		u.OfWebFetchTool20250910,
		u.OfWebSearchTool20260209,
		u.OfWebFetchTool20260209,
		u.OfWebFetchTool20260309,
		u.OfWebSearchTool20260318,
		u.OfWebFetchTool20260318,
		u.OfAdvisorTool20260301,
		u.OfToolSearchToolBm25_20251119,
		u.OfToolSearchToolRegex20251119,
		u.OfMCPToolset)
}
func (u *BetaMessageCountTokensParamsToolUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, u)
}

func (u *BetaMessageCountTokensParamsToolUnion) asAny() any {
	if !param.IsOmitted(u.OfTool) {
		return u.OfTool
	} else if !param.IsOmitted(u.OfBashTool20241022) {
		return u.OfBashTool20241022
	} else if !param.IsOmitted(u.OfBashTool20250124) {
		return u.OfBashTool20250124
	} else if !param.IsOmitted(u.OfCodeExecutionTool20250522) {
		return u.OfCodeExecutionTool20250522
	} else if !param.IsOmitted(u.OfCodeExecutionTool20250825) {
		return u.OfCodeExecutionTool20250825
	} else if !param.IsOmitted(u.OfCodeExecutionTool20260120) {
		return u.OfCodeExecutionTool20260120
	} else if !param.IsOmitted(u.OfCodeExecutionTool20260521) {
		return u.OfCodeExecutionTool20260521
	} else if !param.IsOmitted(u.OfBrowserToolset20260801) {
		return u.OfBrowserToolset20260801
	} else if !param.IsOmitted(u.OfComputerUseTool20241022) {
		return u.OfComputerUseTool20241022
	} else if !param.IsOmitted(u.OfMemoryTool20250818) {
		return u.OfMemoryTool20250818
	} else if !param.IsOmitted(u.OfComputerUseTool20250124) {
		return u.OfComputerUseTool20250124
	} else if !param.IsOmitted(u.OfTextEditor20241022) {
		return u.OfTextEditor20241022
	} else if !param.IsOmitted(u.OfComputerUseTool20251124) {
		return u.OfComputerUseTool20251124
	} else if !param.IsOmitted(u.OfComputerToolset20260801) {
		return u.OfComputerToolset20260801
	} else if !param.IsOmitted(u.OfTextEditor20250124) {
		return u.OfTextEditor20250124
	} else if !param.IsOmitted(u.OfTextEditor20250429) {
		return u.OfTextEditor20250429
	} else if !param.IsOmitted(u.OfTextEditor20250728) {
		return u.OfTextEditor20250728
	} else if !param.IsOmitted(u.OfWebSearchTool20250305) {
		return u.OfWebSearchTool20250305
	} else if !param.IsOmitted(u.OfWebFetchTool20250910) {
		return u.OfWebFetchTool20250910
	} else if !param.IsOmitted(u.OfWebSearchTool20260209) {
		return u.OfWebSearchTool20260209
	} else if !param.IsOmitted(u.OfWebFetchTool20260209) {
		return u.OfWebFetchTool20260209
	} else if !param.IsOmitted(u.OfWebFetchTool20260309) {
		return u.OfWebFetchTool20260309
	} else if !param.IsOmitted(u.OfWebSearchTool20260318) {
		return u.OfWebSearchTool20260318
	} else if !param.IsOmitted(u.OfWebFetchTool20260318) {
		return u.OfWebFetchTool20260318
	} else if !param.IsOmitted(u.OfAdvisorTool20260301) {
		return u.OfAdvisorTool20260301
	} else if !param.IsOmitted(u.OfToolSearchToolBm25_20251119) {
		return u.OfToolSearchToolBm25_20251119
	} else if !param.IsOmitted(u.OfToolSearchToolRegex20251119) {
		return u.OfToolSearchToolRegex20251119
	} else if !param.IsOmitted(u.OfMCPToolset) {
		return u.OfMCPToolset
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaMessageCountTokensParamsToolUnion) GetInputSchema() *BetaToolInputSchemaParam {
	if vt := u.OfTool; vt != nil {
		return &vt.InputSchema
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaMessageCountTokensParamsToolUnion) GetDescription() *string {
	if vt := u.OfTool; vt != nil && vt.Description.Valid() {
		return &vt.Description.Value
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaMessageCountTokensParamsToolUnion) GetEagerInputStreaming() *bool {
	if vt := u.OfTool; vt != nil && vt.EagerInputStreaming.Valid() {
		return &vt.EagerInputStreaming.Value
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaMessageCountTokensParamsToolUnion) GetEnableZoom() *bool {
	if vt := u.OfComputerUseTool20251124; vt != nil && vt.EnableZoom.Valid() {
		return &vt.EnableZoom.Value
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaMessageCountTokensParamsToolUnion) GetMaxCharacters() *int64 {
	if vt := u.OfTextEditor20250728; vt != nil && vt.MaxCharacters.Valid() {
		return &vt.MaxCharacters.Value
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaMessageCountTokensParamsToolUnion) GetModel() *Model {
	if vt := u.OfAdvisorTool20260301; vt != nil {
		return &vt.Model
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaMessageCountTokensParamsToolUnion) GetCaching() *BetaCacheControlEphemeralParam {
	if vt := u.OfAdvisorTool20260301; vt != nil {
		return &vt.Caching
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaMessageCountTokensParamsToolUnion) GetMaxTokens() *int64 {
	if vt := u.OfAdvisorTool20260301; vt != nil && vt.MaxTokens.Valid() {
		return &vt.MaxTokens.Value
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaMessageCountTokensParamsToolUnion) GetMCPServerName() *string {
	if vt := u.OfMCPToolset; vt != nil {
		return &vt.MCPServerName
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaMessageCountTokensParamsToolUnion) GetDefaultConfig() *BetaMCPToolDefaultConfigParam {
	if vt := u.OfMCPToolset; vt != nil {
		return &vt.DefaultConfig
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaMessageCountTokensParamsToolUnion) GetName() *string {
	if vt := u.OfTool; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfBashTool20241022; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfBashTool20250124; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfCodeExecutionTool20250522; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfCodeExecutionTool20250825; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfCodeExecutionTool20260120; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfCodeExecutionTool20260521; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfComputerUseTool20241022; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfMemoryTool20250818; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfComputerUseTool20250124; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfTextEditor20241022; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfComputerUseTool20251124; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfTextEditor20250124; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfTextEditor20250429; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfTextEditor20250728; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfWebSearchTool20250305; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfWebFetchTool20250910; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfWebSearchTool20260209; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfWebFetchTool20260209; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfWebFetchTool20260309; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfWebSearchTool20260318; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfWebFetchTool20260318; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfAdvisorTool20260301; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfToolSearchToolBm25_20251119; vt != nil {
		return (*string)(&vt.Name)
	} else if vt := u.OfToolSearchToolRegex20251119; vt != nil {
		return (*string)(&vt.Name)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaMessageCountTokensParamsToolUnion) GetDeferLoading() *bool {
	if vt := u.OfTool; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfBashTool20241022; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfBashTool20250124; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfCodeExecutionTool20250522; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfCodeExecutionTool20250825; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfCodeExecutionTool20260120; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfCodeExecutionTool20260521; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfComputerUseTool20241022; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfMemoryTool20250818; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfComputerUseTool20250124; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfTextEditor20241022; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfComputerUseTool20251124; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfTextEditor20250124; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfTextEditor20250429; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfTextEditor20250728; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfWebSearchTool20250305; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfWebFetchTool20250910; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfWebSearchTool20260209; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfWebFetchTool20260209; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfWebFetchTool20260309; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfWebSearchTool20260318; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfWebFetchTool20260318; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfAdvisorTool20260301; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfToolSearchToolBm25_20251119; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	} else if vt := u.OfToolSearchToolRegex20251119; vt != nil && vt.DeferLoading.Valid() {
		return &vt.DeferLoading.Value
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaMessageCountTokensParamsToolUnion) GetStrict() *bool {
	if vt := u.OfTool; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfBashTool20241022; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfBashTool20250124; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfCodeExecutionTool20250522; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfCodeExecutionTool20250825; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfCodeExecutionTool20260120; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfCodeExecutionTool20260521; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfComputerUseTool20241022; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfMemoryTool20250818; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfComputerUseTool20250124; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfTextEditor20241022; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfComputerUseTool20251124; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfTextEditor20250124; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfTextEditor20250429; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfTextEditor20250728; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfWebSearchTool20250305; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfWebFetchTool20250910; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfWebSearchTool20260209; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfWebFetchTool20260209; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfWebFetchTool20260309; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfWebSearchTool20260318; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfWebFetchTool20260318; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfAdvisorTool20260301; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfToolSearchToolBm25_20251119; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	} else if vt := u.OfToolSearchToolRegex20251119; vt != nil && vt.Strict.Valid() {
		return &vt.Strict.Value
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaMessageCountTokensParamsToolUnion) GetType() *string {
	if vt := u.OfTool; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfBashTool20241022; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfBashTool20250124; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfCodeExecutionTool20250522; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfCodeExecutionTool20250825; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfCodeExecutionTool20260120; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfCodeExecutionTool20260521; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfBrowserToolset20260801; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfComputerUseTool20241022; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfMemoryTool20250818; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfComputerUseTool20250124; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfTextEditor20241022; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfComputerUseTool20251124; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfComputerToolset20260801; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfTextEditor20250124; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfTextEditor20250429; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfTextEditor20250728; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfWebSearchTool20250305; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfWebFetchTool20250910; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfWebSearchTool20260209; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfWebFetchTool20260209; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfWebFetchTool20260309; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfWebSearchTool20260318; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfWebFetchTool20260318; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfAdvisorTool20260301; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfToolSearchToolBm25_20251119; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfToolSearchToolRegex20251119; vt != nil {
		return (*string)(&vt.Type)
	} else if vt := u.OfMCPToolset; vt != nil {
		return (*string)(&vt.Type)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaMessageCountTokensParamsToolUnion) GetDisplayHeightPx() *int64 {
	if vt := u.OfComputerUseTool20241022; vt != nil {
		return (*int64)(&vt.DisplayHeightPx)
	} else if vt := u.OfComputerUseTool20250124; vt != nil {
		return (*int64)(&vt.DisplayHeightPx)
	} else if vt := u.OfComputerUseTool20251124; vt != nil {
		return (*int64)(&vt.DisplayHeightPx)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaMessageCountTokensParamsToolUnion) GetDisplayWidthPx() *int64 {
	if vt := u.OfComputerUseTool20241022; vt != nil {
		return (*int64)(&vt.DisplayWidthPx)
	} else if vt := u.OfComputerUseTool20250124; vt != nil {
		return (*int64)(&vt.DisplayWidthPx)
	} else if vt := u.OfComputerUseTool20251124; vt != nil {
		return (*int64)(&vt.DisplayWidthPx)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaMessageCountTokensParamsToolUnion) GetDisplayNumber() *int64 {
	if vt := u.OfComputerUseTool20241022; vt != nil && vt.DisplayNumber.Valid() {
		return &vt.DisplayNumber.Value
	} else if vt := u.OfComputerUseTool20250124; vt != nil && vt.DisplayNumber.Valid() {
		return &vt.DisplayNumber.Value
	} else if vt := u.OfComputerUseTool20251124; vt != nil && vt.DisplayNumber.Valid() {
		return &vt.DisplayNumber.Value
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaMessageCountTokensParamsToolUnion) GetMaxUses() *int64 {
	if vt := u.OfWebSearchTool20250305; vt != nil && vt.MaxUses.Valid() {
		return &vt.MaxUses.Value
	} else if vt := u.OfWebFetchTool20250910; vt != nil && vt.MaxUses.Valid() {
		return &vt.MaxUses.Value
	} else if vt := u.OfWebSearchTool20260209; vt != nil && vt.MaxUses.Valid() {
		return &vt.MaxUses.Value
	} else if vt := u.OfWebFetchTool20260209; vt != nil && vt.MaxUses.Valid() {
		return &vt.MaxUses.Value
	} else if vt := u.OfWebFetchTool20260309; vt != nil && vt.MaxUses.Valid() {
		return &vt.MaxUses.Value
	} else if vt := u.OfWebSearchTool20260318; vt != nil && vt.MaxUses.Valid() {
		return &vt.MaxUses.Value
	} else if vt := u.OfWebFetchTool20260318; vt != nil && vt.MaxUses.Valid() {
		return &vt.MaxUses.Value
	} else if vt := u.OfAdvisorTool20260301; vt != nil && vt.MaxUses.Valid() {
		return &vt.MaxUses.Value
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaMessageCountTokensParamsToolUnion) GetMaxContentTokens() *int64 {
	if vt := u.OfWebFetchTool20250910; vt != nil && vt.MaxContentTokens.Valid() {
		return &vt.MaxContentTokens.Value
	} else if vt := u.OfWebFetchTool20260209; vt != nil && vt.MaxContentTokens.Valid() {
		return &vt.MaxContentTokens.Value
	} else if vt := u.OfWebFetchTool20260309; vt != nil && vt.MaxContentTokens.Valid() {
		return &vt.MaxContentTokens.Value
	} else if vt := u.OfWebFetchTool20260318; vt != nil && vt.MaxContentTokens.Valid() {
		return &vt.MaxContentTokens.Value
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaMessageCountTokensParamsToolUnion) GetUseCache() *bool {
	if vt := u.OfWebFetchTool20260309; vt != nil && vt.UseCache.Valid() {
		return &vt.UseCache.Value
	} else if vt := u.OfWebFetchTool20260318; vt != nil && vt.UseCache.Valid() {
		return &vt.UseCache.Value
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u BetaMessageCountTokensParamsToolUnion) GetResponseInclusion() *string {
	if vt := u.OfWebSearchTool20260318; vt != nil {
		return (*string)(&vt.ResponseInclusion)
	} else if vt := u.OfWebFetchTool20260318; vt != nil {
		return (*string)(&vt.ResponseInclusion)
	}
	return nil
}

// Returns a pointer to the underlying variant's AllowedCallers property, if
// present.
func (u BetaMessageCountTokensParamsToolUnion) GetAllowedCallers() []string {
	if vt := u.OfTool; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfBashTool20241022; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfBashTool20250124; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfCodeExecutionTool20250522; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfCodeExecutionTool20250825; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfCodeExecutionTool20260120; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfCodeExecutionTool20260521; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfComputerUseTool20241022; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfMemoryTool20250818; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfComputerUseTool20250124; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfTextEditor20241022; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfComputerUseTool20251124; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfTextEditor20250124; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfTextEditor20250429; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfTextEditor20250728; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfWebSearchTool20250305; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfWebFetchTool20250910; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfWebSearchTool20260209; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfWebFetchTool20260209; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfWebFetchTool20260309; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfWebSearchTool20260318; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfWebFetchTool20260318; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfAdvisorTool20260301; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfToolSearchToolBm25_20251119; vt != nil {
		return vt.AllowedCallers
	} else if vt := u.OfToolSearchToolRegex20251119; vt != nil {
		return vt.AllowedCallers
	}
	return nil
}

// Returns a pointer to the underlying variant's CacheControl property, if present.
func (u BetaMessageCountTokensParamsToolUnion) GetCacheControl() *BetaCacheControlEphemeralParam {
	if vt := u.OfTool; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfBashTool20241022; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfBashTool20250124; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfCodeExecutionTool20250522; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfCodeExecutionTool20250825; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfCodeExecutionTool20260120; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfCodeExecutionTool20260521; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfBrowserToolset20260801; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfComputerUseTool20241022; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfMemoryTool20250818; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfComputerUseTool20250124; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfTextEditor20241022; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfComputerUseTool20251124; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfComputerToolset20260801; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfTextEditor20250124; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfTextEditor20250429; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfTextEditor20250728; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfWebSearchTool20250305; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfWebFetchTool20250910; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfWebSearchTool20260209; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfWebFetchTool20260209; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfWebFetchTool20260309; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfWebSearchTool20260318; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfWebFetchTool20260318; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfAdvisorTool20260301; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfToolSearchToolBm25_20251119; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfToolSearchToolRegex20251119; vt != nil {
		return &vt.CacheControl
	} else if vt := u.OfMCPToolset; vt != nil {
		return &vt.CacheControl
	}
	return nil
}

// Returns a pointer to the underlying variant's InputExamples property, if
// present.
func (u BetaMessageCountTokensParamsToolUnion) GetInputExamples() []map[string]any {
	if vt := u.OfTool; vt != nil {
		return vt.InputExamples
	} else if vt := u.OfBashTool20241022; vt != nil {
		return vt.InputExamples
	} else if vt := u.OfBashTool20250124; vt != nil {
		return vt.InputExamples
	} else if vt := u.OfComputerUseTool20241022; vt != nil {
		return vt.InputExamples
	} else if vt := u.OfMemoryTool20250818; vt != nil {
		return vt.InputExamples
	} else if vt := u.OfComputerUseTool20250124; vt != nil {
		return vt.InputExamples
	} else if vt := u.OfTextEditor20241022; vt != nil {
		return vt.InputExamples
	} else if vt := u.OfComputerUseTool20251124; vt != nil {
		return vt.InputExamples
	} else if vt := u.OfTextEditor20250124; vt != nil {
		return vt.InputExamples
	} else if vt := u.OfTextEditor20250429; vt != nil {
		return vt.InputExamples
	} else if vt := u.OfTextEditor20250728; vt != nil {
		return vt.InputExamples
	}
	return nil
}

// Returns a subunion which exports methods to access subproperties
//
// Or use AsAny() to get the underlying value
func (u BetaMessageCountTokensParamsToolUnion) GetConfigs() (res betaMessageCountTokensParamsToolUnionConfigs) {
	if vt := u.OfBrowserToolset20260801; vt != nil {
		res.any = &vt.Configs
	} else if vt := u.OfComputerToolset20260801; vt != nil {
		res.any = &vt.Configs
	} else if vt := u.OfMCPToolset; vt != nil {
		res.any = &vt.Configs
	}
	return
}

// Can have the runtime types [*BetaBrowserToolsetConfigsParam],
// [*BetaComputerToolsetConfigsParam], [\*map[string]BetaMCPToolConfigParam]
type betaMessageCountTokensParamsToolUnionConfigs struct{ any }

// Use the following switch statement to get the type of the union:
//
//	switch u.AsAny().(type) {
//	case *anthropic.BetaBrowserToolsetConfigsParam:
//	case *anthropic.BetaComputerToolsetConfigsParam:
//	case *map[string]anthropic.BetaMCPToolConfigParam:
//	default:
//	    fmt.Errorf("not present")
//	}
func (u betaMessageCountTokensParamsToolUnionConfigs) AsAny() any { return u.any }

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigs) GetCloseTab() *BetaBrowserCloseTabConfigParam {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		return &vt.CloseTab
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigs) GetFileUpload() *BetaBrowserFileUploadConfigParam {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		return &vt.FileUpload
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigs) GetFind() *BetaBrowserFindConfigParam {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		return &vt.Find
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigs) GetFormInput() *BetaBrowserFormInputConfigParam {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		return &vt.FormInput
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigs) GetGetPageText() *BetaBrowserGetPageTextConfigParam {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		return &vt.GetPageText
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigs) GetHover() *BetaBrowserHoverConfigParam {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		return &vt.Hover
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigs) GetJavascriptExec() *BetaBrowserJavascriptExecConfigParam {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		return &vt.JavascriptExec
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigs) GetListTabs() *BetaBrowserListTabsConfigParam {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		return &vt.ListTabs
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigs) GetNavigate() *BetaBrowserNavigateConfigParam {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		return &vt.Navigate
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigs) GetNewTab() *BetaBrowserNewTabConfigParam {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		return &vt.NewTab
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigs) GetReadConsole() *BetaBrowserReadConsoleConfigParam {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		return &vt.ReadConsole
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigs) GetReadNetwork() *BetaBrowserReadNetworkConfigParam {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		return &vt.ReadNetwork
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigs) GetReadPage() *BetaBrowserReadPageConfigParam {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		return &vt.ReadPage
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigs) GetScrollTo() *BetaBrowserScrollToConfigParam {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		return &vt.ScrollTo
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigs) GetSwitchTab() *BetaBrowserSwitchTabConfigParam {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		return &vt.SwitchTab
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigs) GetCursorPosition() *BetaComputerCursorPositionConfigParam {
	switch vt := u.any.(type) {
	case *BetaComputerToolsetConfigsParam:
		return &vt.CursorPosition
	}
	return nil
}

// Returns a subunion which exports methods to access subproperties
//
// Or use AsAny() to get the underlying value
func (u betaMessageCountTokensParamsToolUnionConfigs) GetDoubleClick() (res betaMessageCountTokensParamsToolUnionConfigsDoubleClick) {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		res.any = &vt.DoubleClick
	case *BetaComputerToolsetConfigsParam:
		res.any = &vt.DoubleClick
	}
	return res
}

// Can have the runtime types [*BetaBrowserDoubleClickConfigParam],
// [*BetaComputerDoubleClickConfigParam]
type betaMessageCountTokensParamsToolUnionConfigsDoubleClick struct{ any }

// Use the following switch statement to get the type of the union:
//
//	switch u.AsAny().(type) {
//	case *anthropic.BetaBrowserDoubleClickConfigParam:
//	case *anthropic.BetaComputerDoubleClickConfigParam:
//	default:
//	    fmt.Errorf("not present")
//	}
func (u betaMessageCountTokensParamsToolUnionConfigsDoubleClick) AsAny() any { return u.any }

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigsDoubleClick) GetDeferLoading() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserDoubleClickConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	case *BetaComputerDoubleClickConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigsDoubleClick) GetEnabled() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserDoubleClickConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	case *BetaComputerDoubleClickConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	}
	return nil
}

// Returns a subunion which exports methods to access subproperties
//
// Or use AsAny() to get the underlying value
func (u betaMessageCountTokensParamsToolUnionConfigs) GetHoldKey() (res betaMessageCountTokensParamsToolUnionConfigsHoldKey) {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		res.any = &vt.HoldKey
	case *BetaComputerToolsetConfigsParam:
		res.any = &vt.HoldKey
	}
	return res
}

// Can have the runtime types [*BetaBrowserHoldKeyConfigParam],
// [*BetaComputerHoldKeyConfigParam]
type betaMessageCountTokensParamsToolUnionConfigsHoldKey struct{ any }

// Use the following switch statement to get the type of the union:
//
//	switch u.AsAny().(type) {
//	case *anthropic.BetaBrowserHoldKeyConfigParam:
//	case *anthropic.BetaComputerHoldKeyConfigParam:
//	default:
//	    fmt.Errorf("not present")
//	}
func (u betaMessageCountTokensParamsToolUnionConfigsHoldKey) AsAny() any { return u.any }

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigsHoldKey) GetDeferLoading() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserHoldKeyConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	case *BetaComputerHoldKeyConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigsHoldKey) GetEnabled() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserHoldKeyConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	case *BetaComputerHoldKeyConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	}
	return nil
}

// Returns a subunion which exports methods to access subproperties
//
// Or use AsAny() to get the underlying value
func (u betaMessageCountTokensParamsToolUnionConfigs) GetKey() (res betaMessageCountTokensParamsToolUnionConfigsKey) {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		res.any = &vt.Key
	case *BetaComputerToolsetConfigsParam:
		res.any = &vt.Key
	}
	return res
}

// Can have the runtime types [*BetaBrowserKeyConfigParam],
// [*BetaComputerKeyConfigParam]
type betaMessageCountTokensParamsToolUnionConfigsKey struct{ any }

// Use the following switch statement to get the type of the union:
//
//	switch u.AsAny().(type) {
//	case *anthropic.BetaBrowserKeyConfigParam:
//	case *anthropic.BetaComputerKeyConfigParam:
//	default:
//	    fmt.Errorf("not present")
//	}
func (u betaMessageCountTokensParamsToolUnionConfigsKey) AsAny() any { return u.any }

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigsKey) GetDeferLoading() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserKeyConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	case *BetaComputerKeyConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigsKey) GetEnabled() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserKeyConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	case *BetaComputerKeyConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	}
	return nil
}

// Returns a subunion which exports methods to access subproperties
//
// Or use AsAny() to get the underlying value
func (u betaMessageCountTokensParamsToolUnionConfigs) GetLeftClick() (res betaMessageCountTokensParamsToolUnionConfigsLeftClick) {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		res.any = &vt.LeftClick
	case *BetaComputerToolsetConfigsParam:
		res.any = &vt.LeftClick
	}
	return res
}

// Can have the runtime types [*BetaBrowserLeftClickConfigParam],
// [*BetaComputerLeftClickConfigParam]
type betaMessageCountTokensParamsToolUnionConfigsLeftClick struct{ any }

// Use the following switch statement to get the type of the union:
//
//	switch u.AsAny().(type) {
//	case *anthropic.BetaBrowserLeftClickConfigParam:
//	case *anthropic.BetaComputerLeftClickConfigParam:
//	default:
//	    fmt.Errorf("not present")
//	}
func (u betaMessageCountTokensParamsToolUnionConfigsLeftClick) AsAny() any { return u.any }

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigsLeftClick) GetDeferLoading() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserLeftClickConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	case *BetaComputerLeftClickConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigsLeftClick) GetEnabled() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserLeftClickConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	case *BetaComputerLeftClickConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	}
	return nil
}

// Returns a subunion which exports methods to access subproperties
//
// Or use AsAny() to get the underlying value
func (u betaMessageCountTokensParamsToolUnionConfigs) GetLeftClickDrag() (res betaMessageCountTokensParamsToolUnionConfigsLeftClickDrag) {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		res.any = &vt.LeftClickDrag
	case *BetaComputerToolsetConfigsParam:
		res.any = &vt.LeftClickDrag
	}
	return res
}

// Can have the runtime types [*BetaBrowserLeftClickDragConfigParam],
// [*BetaComputerLeftClickDragConfigParam]
type betaMessageCountTokensParamsToolUnionConfigsLeftClickDrag struct{ any }

// Use the following switch statement to get the type of the union:
//
//	switch u.AsAny().(type) {
//	case *anthropic.BetaBrowserLeftClickDragConfigParam:
//	case *anthropic.BetaComputerLeftClickDragConfigParam:
//	default:
//	    fmt.Errorf("not present")
//	}
func (u betaMessageCountTokensParamsToolUnionConfigsLeftClickDrag) AsAny() any { return u.any }

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigsLeftClickDrag) GetDeferLoading() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserLeftClickDragConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	case *BetaComputerLeftClickDragConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigsLeftClickDrag) GetEnabled() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserLeftClickDragConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	case *BetaComputerLeftClickDragConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	}
	return nil
}

// Returns a subunion which exports methods to access subproperties
//
// Or use AsAny() to get the underlying value
func (u betaMessageCountTokensParamsToolUnionConfigs) GetLeftMouseDown() (res betaMessageCountTokensParamsToolUnionConfigsLeftMouseDown) {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		res.any = &vt.LeftMouseDown
	case *BetaComputerToolsetConfigsParam:
		res.any = &vt.LeftMouseDown
	}
	return res
}

// Can have the runtime types [*BetaBrowserLeftMouseDownConfigParam],
// [*BetaComputerLeftMouseDownConfigParam]
type betaMessageCountTokensParamsToolUnionConfigsLeftMouseDown struct{ any }

// Use the following switch statement to get the type of the union:
//
//	switch u.AsAny().(type) {
//	case *anthropic.BetaBrowserLeftMouseDownConfigParam:
//	case *anthropic.BetaComputerLeftMouseDownConfigParam:
//	default:
//	    fmt.Errorf("not present")
//	}
func (u betaMessageCountTokensParamsToolUnionConfigsLeftMouseDown) AsAny() any { return u.any }

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigsLeftMouseDown) GetDeferLoading() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserLeftMouseDownConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	case *BetaComputerLeftMouseDownConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigsLeftMouseDown) GetEnabled() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserLeftMouseDownConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	case *BetaComputerLeftMouseDownConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	}
	return nil
}

// Returns a subunion which exports methods to access subproperties
//
// Or use AsAny() to get the underlying value
func (u betaMessageCountTokensParamsToolUnionConfigs) GetLeftMouseUp() (res betaMessageCountTokensParamsToolUnionConfigsLeftMouseUp) {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		res.any = &vt.LeftMouseUp
	case *BetaComputerToolsetConfigsParam:
		res.any = &vt.LeftMouseUp
	}
	return res
}

// Can have the runtime types [*BetaBrowserLeftMouseUpConfigParam],
// [*BetaComputerLeftMouseUpConfigParam]
type betaMessageCountTokensParamsToolUnionConfigsLeftMouseUp struct{ any }

// Use the following switch statement to get the type of the union:
//
//	switch u.AsAny().(type) {
//	case *anthropic.BetaBrowserLeftMouseUpConfigParam:
//	case *anthropic.BetaComputerLeftMouseUpConfigParam:
//	default:
//	    fmt.Errorf("not present")
//	}
func (u betaMessageCountTokensParamsToolUnionConfigsLeftMouseUp) AsAny() any { return u.any }

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigsLeftMouseUp) GetDeferLoading() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserLeftMouseUpConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	case *BetaComputerLeftMouseUpConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigsLeftMouseUp) GetEnabled() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserLeftMouseUpConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	case *BetaComputerLeftMouseUpConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	}
	return nil
}

// Returns a subunion which exports methods to access subproperties
//
// Or use AsAny() to get the underlying value
func (u betaMessageCountTokensParamsToolUnionConfigs) GetMiddleClick() (res betaMessageCountTokensParamsToolUnionConfigsMiddleClick) {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		res.any = &vt.MiddleClick
	case *BetaComputerToolsetConfigsParam:
		res.any = &vt.MiddleClick
	}
	return res
}

// Can have the runtime types [*BetaBrowserMiddleClickConfigParam],
// [*BetaComputerMiddleClickConfigParam]
type betaMessageCountTokensParamsToolUnionConfigsMiddleClick struct{ any }

// Use the following switch statement to get the type of the union:
//
//	switch u.AsAny().(type) {
//	case *anthropic.BetaBrowserMiddleClickConfigParam:
//	case *anthropic.BetaComputerMiddleClickConfigParam:
//	default:
//	    fmt.Errorf("not present")
//	}
func (u betaMessageCountTokensParamsToolUnionConfigsMiddleClick) AsAny() any { return u.any }

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigsMiddleClick) GetDeferLoading() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserMiddleClickConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	case *BetaComputerMiddleClickConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigsMiddleClick) GetEnabled() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserMiddleClickConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	case *BetaComputerMiddleClickConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	}
	return nil
}

// Returns a subunion which exports methods to access subproperties
//
// Or use AsAny() to get the underlying value
func (u betaMessageCountTokensParamsToolUnionConfigs) GetMouseMove() (res betaMessageCountTokensParamsToolUnionConfigsMouseMove) {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		res.any = &vt.MouseMove
	case *BetaComputerToolsetConfigsParam:
		res.any = &vt.MouseMove
	}
	return res
}

// Can have the runtime types [*BetaBrowserMouseMoveConfigParam],
// [*BetaComputerMouseMoveConfigParam]
type betaMessageCountTokensParamsToolUnionConfigsMouseMove struct{ any }

// Use the following switch statement to get the type of the union:
//
//	switch u.AsAny().(type) {
//	case *anthropic.BetaBrowserMouseMoveConfigParam:
//	case *anthropic.BetaComputerMouseMoveConfigParam:
//	default:
//	    fmt.Errorf("not present")
//	}
func (u betaMessageCountTokensParamsToolUnionConfigsMouseMove) AsAny() any { return u.any }

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigsMouseMove) GetDeferLoading() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserMouseMoveConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	case *BetaComputerMouseMoveConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigsMouseMove) GetEnabled() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserMouseMoveConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	case *BetaComputerMouseMoveConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	}
	return nil
}

// Returns a subunion which exports methods to access subproperties
//
// Or use AsAny() to get the underlying value
func (u betaMessageCountTokensParamsToolUnionConfigs) GetRightClick() (res betaMessageCountTokensParamsToolUnionConfigsRightClick) {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		res.any = &vt.RightClick
	case *BetaComputerToolsetConfigsParam:
		res.any = &vt.RightClick
	}
	return res
}

// Can have the runtime types [*BetaBrowserRightClickConfigParam],
// [*BetaComputerRightClickConfigParam]
type betaMessageCountTokensParamsToolUnionConfigsRightClick struct{ any }

// Use the following switch statement to get the type of the union:
//
//	switch u.AsAny().(type) {
//	case *anthropic.BetaBrowserRightClickConfigParam:
//	case *anthropic.BetaComputerRightClickConfigParam:
//	default:
//	    fmt.Errorf("not present")
//	}
func (u betaMessageCountTokensParamsToolUnionConfigsRightClick) AsAny() any { return u.any }

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigsRightClick) GetDeferLoading() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserRightClickConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	case *BetaComputerRightClickConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigsRightClick) GetEnabled() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserRightClickConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	case *BetaComputerRightClickConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	}
	return nil
}

// Returns a subunion which exports methods to access subproperties
//
// Or use AsAny() to get the underlying value
func (u betaMessageCountTokensParamsToolUnionConfigs) GetScreenshot() (res betaMessageCountTokensParamsToolUnionConfigsScreenshot) {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		res.any = &vt.Screenshot
	case *BetaComputerToolsetConfigsParam:
		res.any = &vt.Screenshot
	}
	return res
}

// Can have the runtime types [*BetaBrowserScreenshotConfigParam],
// [*BetaComputerScreenshotConfigParam]
type betaMessageCountTokensParamsToolUnionConfigsScreenshot struct{ any }

// Use the following switch statement to get the type of the union:
//
//	switch u.AsAny().(type) {
//	case *anthropic.BetaBrowserScreenshotConfigParam:
//	case *anthropic.BetaComputerScreenshotConfigParam:
//	default:
//	    fmt.Errorf("not present")
//	}
func (u betaMessageCountTokensParamsToolUnionConfigsScreenshot) AsAny() any { return u.any }

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigsScreenshot) GetDeferLoading() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserScreenshotConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	case *BetaComputerScreenshotConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigsScreenshot) GetEnabled() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserScreenshotConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	case *BetaComputerScreenshotConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	}
	return nil
}

// Returns a subunion which exports methods to access subproperties
//
// Or use AsAny() to get the underlying value
func (u betaMessageCountTokensParamsToolUnionConfigs) GetScroll() (res betaMessageCountTokensParamsToolUnionConfigsScroll) {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		res.any = &vt.Scroll
	case *BetaComputerToolsetConfigsParam:
		res.any = &vt.Scroll
	}
	return res
}

// Can have the runtime types [*BetaBrowserScrollConfigParam],
// [*BetaComputerScrollConfigParam]
type betaMessageCountTokensParamsToolUnionConfigsScroll struct{ any }

// Use the following switch statement to get the type of the union:
//
//	switch u.AsAny().(type) {
//	case *anthropic.BetaBrowserScrollConfigParam:
//	case *anthropic.BetaComputerScrollConfigParam:
//	default:
//	    fmt.Errorf("not present")
//	}
func (u betaMessageCountTokensParamsToolUnionConfigsScroll) AsAny() any { return u.any }

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigsScroll) GetDeferLoading() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserScrollConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	case *BetaComputerScrollConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigsScroll) GetEnabled() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserScrollConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	case *BetaComputerScrollConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	}
	return nil
}

// Returns a subunion which exports methods to access subproperties
//
// Or use AsAny() to get the underlying value
func (u betaMessageCountTokensParamsToolUnionConfigs) GetTripleClick() (res betaMessageCountTokensParamsToolUnionConfigsTripleClick) {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		res.any = &vt.TripleClick
	case *BetaComputerToolsetConfigsParam:
		res.any = &vt.TripleClick
	}
	return res
}

// Can have the runtime types [*BetaBrowserTripleClickConfigParam],
// [*BetaComputerTripleClickConfigParam]
type betaMessageCountTokensParamsToolUnionConfigsTripleClick struct{ any }

// Use the following switch statement to get the type of the union:
//
//	switch u.AsAny().(type) {
//	case *anthropic.BetaBrowserTripleClickConfigParam:
//	case *anthropic.BetaComputerTripleClickConfigParam:
//	default:
//	    fmt.Errorf("not present")
//	}
func (u betaMessageCountTokensParamsToolUnionConfigsTripleClick) AsAny() any { return u.any }

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigsTripleClick) GetDeferLoading() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserTripleClickConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	case *BetaComputerTripleClickConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigsTripleClick) GetEnabled() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserTripleClickConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	case *BetaComputerTripleClickConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	}
	return nil
}

// Returns a subunion which exports methods to access subproperties
//
// Or use AsAny() to get the underlying value
func (u betaMessageCountTokensParamsToolUnionConfigs) GetType() (res betaMessageCountTokensParamsToolUnionConfigsType) {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		res.any = &vt.Type
	case *BetaComputerToolsetConfigsParam:
		res.any = &vt.Type
	}
	return res
}

// Can have the runtime types [*BetaBrowserTypeConfigParam],
// [*BetaComputerTypeConfigParam]
type betaMessageCountTokensParamsToolUnionConfigsType struct{ any }

// Use the following switch statement to get the type of the union:
//
//	switch u.AsAny().(type) {
//	case *anthropic.BetaBrowserTypeConfigParam:
//	case *anthropic.BetaComputerTypeConfigParam:
//	default:
//	    fmt.Errorf("not present")
//	}
func (u betaMessageCountTokensParamsToolUnionConfigsType) AsAny() any { return u.any }

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigsType) GetDeferLoading() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserTypeConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	case *BetaComputerTypeConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigsType) GetEnabled() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserTypeConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	case *BetaComputerTypeConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	}
	return nil
}

// Returns a subunion which exports methods to access subproperties
//
// Or use AsAny() to get the underlying value
func (u betaMessageCountTokensParamsToolUnionConfigs) GetWait() (res betaMessageCountTokensParamsToolUnionConfigsWait) {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		res.any = &vt.Wait
	case *BetaComputerToolsetConfigsParam:
		res.any = &vt.Wait
	}
	return res
}

// Can have the runtime types [*BetaBrowserWaitConfigParam],
// [*BetaComputerWaitConfigParam]
type betaMessageCountTokensParamsToolUnionConfigsWait struct{ any }

// Use the following switch statement to get the type of the union:
//
//	switch u.AsAny().(type) {
//	case *anthropic.BetaBrowserWaitConfigParam:
//	case *anthropic.BetaComputerWaitConfigParam:
//	default:
//	    fmt.Errorf("not present")
//	}
func (u betaMessageCountTokensParamsToolUnionConfigsWait) AsAny() any { return u.any }

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigsWait) GetDeferLoading() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserWaitConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	case *BetaComputerWaitConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigsWait) GetEnabled() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserWaitConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	case *BetaComputerWaitConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	}
	return nil
}

// Returns a subunion which exports methods to access subproperties
//
// Or use AsAny() to get the underlying value
func (u betaMessageCountTokensParamsToolUnionConfigs) GetZoom() (res betaMessageCountTokensParamsToolUnionConfigsZoom) {
	switch vt := u.any.(type) {
	case *BetaBrowserToolsetConfigsParam:
		res.any = &vt.Zoom
	case *BetaComputerToolsetConfigsParam:
		res.any = &vt.Zoom
	}
	return res
}

// Can have the runtime types [*BetaBrowserZoomConfigParam],
// [*BetaComputerZoomConfigParam]
type betaMessageCountTokensParamsToolUnionConfigsZoom struct{ any }

// Use the following switch statement to get the type of the union:
//
//	switch u.AsAny().(type) {
//	case *anthropic.BetaBrowserZoomConfigParam:
//	case *anthropic.BetaComputerZoomConfigParam:
//	default:
//	    fmt.Errorf("not present")
//	}
func (u betaMessageCountTokensParamsToolUnionConfigsZoom) AsAny() any { return u.any }

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigsZoom) GetDeferLoading() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserZoomConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	case *BetaComputerZoomConfigParam:
		return paramutil.AddrIfPresent(vt.DeferLoading)
	}
	return nil
}

// Returns a pointer to the underlying variant's property, if present.
func (u betaMessageCountTokensParamsToolUnionConfigsZoom) GetEnabled() *bool {
	switch vt := u.any.(type) {
	case *BetaBrowserZoomConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	case *BetaComputerZoomConfigParam:
		return paramutil.AddrIfPresent(vt.Enabled)
	}
	return nil
}

// Returns a pointer to the underlying variant's AllowedDomains property, if
// present.
func (u BetaMessageCountTokensParamsToolUnion) GetAllowedDomains() []string {
	if vt := u.OfWebSearchTool20250305; vt != nil {
		return vt.AllowedDomains
	} else if vt := u.OfWebFetchTool20250910; vt != nil {
		return vt.AllowedDomains
	} else if vt := u.OfWebSearchTool20260209; vt != nil {
		return vt.AllowedDomains
	} else if vt := u.OfWebFetchTool20260209; vt != nil {
		return vt.AllowedDomains
	} else if vt := u.OfWebFetchTool20260309; vt != nil {
		return vt.AllowedDomains
	} else if vt := u.OfWebSearchTool20260318; vt != nil {
		return vt.AllowedDomains
	} else if vt := u.OfWebFetchTool20260318; vt != nil {
		return vt.AllowedDomains
	}
	return nil
}

// Returns a pointer to the underlying variant's BlockedDomains property, if
// present.
func (u BetaMessageCountTokensParamsToolUnion) GetBlockedDomains() []string {
	if vt := u.OfWebSearchTool20250305; vt != nil {
		return vt.BlockedDomains
	} else if vt := u.OfWebFetchTool20250910; vt != nil {
		return vt.BlockedDomains
	} else if vt := u.OfWebSearchTool20260209; vt != nil {
		return vt.BlockedDomains
	} else if vt := u.OfWebFetchTool20260209; vt != nil {
		return vt.BlockedDomains
	} else if vt := u.OfWebFetchTool20260309; vt != nil {
		return vt.BlockedDomains
	} else if vt := u.OfWebSearchTool20260318; vt != nil {
		return vt.BlockedDomains
	} else if vt := u.OfWebFetchTool20260318; vt != nil {
		return vt.BlockedDomains
	}
	return nil
}

// Returns a pointer to the underlying variant's UserLocation property, if present.
func (u BetaMessageCountTokensParamsToolUnion) GetUserLocation() *BetaUserLocationParam {
	if vt := u.OfWebSearchTool20250305; vt != nil {
		return &vt.UserLocation
	} else if vt := u.OfWebSearchTool20260209; vt != nil {
		return &vt.UserLocation
	} else if vt := u.OfWebSearchTool20260318; vt != nil {
		return &vt.UserLocation
	}
	return nil
}

// Returns a pointer to the underlying variant's Citations property, if present.
func (u BetaMessageCountTokensParamsToolUnion) GetCitations() *BetaCitationsConfigParam {
	if vt := u.OfWebFetchTool20250910; vt != nil {
		return &vt.Citations
	} else if vt := u.OfWebFetchTool20260209; vt != nil {
		return &vt.Citations
	} else if vt := u.OfWebFetchTool20260309; vt != nil {
		return &vt.Citations
	} else if vt := u.OfWebFetchTool20260318; vt != nil {
		return &vt.Citations
	}
	return nil
}