zrpc_encoding.go

// Code generated by scripts/codegen/go.ts; DO NOT EDIT.
// Source: api.schema.json

package rpc

import (
	"encoding/json"
	"errors"
)

func unmarshalAuthInfo(data []byte) (AuthInfo, error) {
	if string(data) == "null" {
		return nil, nil
	}
	type rawUnion struct {
		Type AuthInfoType `json:"type"`
	}
	var raw rawUnion
	if err := json.Unmarshal(data, &raw); err != nil {
		return nil, err
	}

	switch raw.Type {
	case AuthInfoTypeAPIKey:
		var d APIKeyAuthInfo
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case AuthInfoTypeCopilotAPIToken:
		var d CopilotAPITokenAuthInfo
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case AuthInfoTypeEnv:
		var d EnvAuthInfo
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case AuthInfoTypeGhCli:
		var d GhCliAuthInfo
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case AuthInfoTypeHmac:
		var d HMACAuthInfo
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case AuthInfoTypeToken:
		var d TokenAuthInfo
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case AuthInfoTypeUser:
		var d UserAuthInfo
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	default:
		return &RawAuthInfoData{Discriminator: raw.Type, Raw: data}, nil
	}
}

func (r RawAuthInfoData) MarshalJSON() ([]byte, error) {
	if r.Raw != nil {
		return r.Raw, nil
	}
	return json.Marshal(struct {
		Type AuthInfoType `json:"type"`
	}{
		Type: r.Discriminator,
	})
}

func (r APIKeyAuthInfo) MarshalJSON() ([]byte, error) {
	type alias APIKeyAuthInfo
	return json.Marshal(struct {
		Type AuthInfoType `json:"type"`
		alias
	}{
		Type:  r.Type(),
		alias: alias(r),
	})
}

func (r CopilotAPITokenAuthInfo) MarshalJSON() ([]byte, error) {
	type alias CopilotAPITokenAuthInfo
	return json.Marshal(struct {
		Type AuthInfoType `json:"type"`
		alias
	}{
		Type:  r.Type(),
		alias: alias(r),
	})
}

func (r EnvAuthInfo) MarshalJSON() ([]byte, error) {
	type alias EnvAuthInfo
	return json.Marshal(struct {
		Type AuthInfoType `json:"type"`
		alias
	}{
		Type:  r.Type(),
		alias: alias(r),
	})
}

func (r GhCliAuthInfo) MarshalJSON() ([]byte, error) {
	type alias GhCliAuthInfo
	return json.Marshal(struct {
		Type AuthInfoType `json:"type"`
		alias
	}{
		Type:  r.Type(),
		alias: alias(r),
	})
}

func (r HMACAuthInfo) MarshalJSON() ([]byte, error) {
	type alias HMACAuthInfo
	return json.Marshal(struct {
		Type AuthInfoType `json:"type"`
		alias
	}{
		Type:  r.Type(),
		alias: alias(r),
	})
}

func (r TokenAuthInfo) MarshalJSON() ([]byte, error) {
	type alias TokenAuthInfo
	return json.Marshal(struct {
		Type AuthInfoType `json:"type"`
		alias
	}{
		Type:  r.Type(),
		alias: alias(r),
	})
}

func (r UserAuthInfo) MarshalJSON() ([]byte, error) {
	type alias UserAuthInfo
	return json.Marshal(struct {
		Type AuthInfoType `json:"type"`
		alias
	}{
		Type:  r.Type(),
		alias: alias(r),
	})
}

func unmarshalQueuedCommandResult(data []byte) (QueuedCommandResult, error) {
	if string(data) == "null" {
		return nil, nil
	}
	type rawUnion struct {
		Handled *bool `json:"handled"`
	}
	var raw rawUnion
	if err := json.Unmarshal(data, &raw); err != nil {
		return nil, err
	}
	if raw.Handled == nil {
		return nil, errors.New("data did not match any union variant for QueuedCommandResult")
	}

	switch *raw.Handled {
	case false:
		var d QueuedCommandNotHandled
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case true:
		var d QueuedCommandHandled
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	}
	return nil, errors.New("data did not match any union variant for QueuedCommandResult")
}

func (r QueuedCommandHandled) MarshalJSON() ([]byte, error) {
	type alias QueuedCommandHandled
	return json.Marshal(struct {
		Handled bool `json:"handled"`
		alias
	}{
		Handled: r.Handled(),
		alias:   alias(r),
	})
}

func (r QueuedCommandNotHandled) MarshalJSON() ([]byte, error) {
	type alias QueuedCommandNotHandled
	return json.Marshal(struct {
		Handled bool `json:"handled"`
		alias
	}{
		Handled: r.Handled(),
		alias:   alias(r),
	})
}

func (r *CommandsRespondToQueuedCommandRequest) UnmarshalJSON(data []byte) error {
	type rawCommandsRespondToQueuedCommandRequest struct {
		RequestID string          `json:"requestId"`
		Result    json.RawMessage `json:"result"`
	}
	var raw rawCommandsRespondToQueuedCommandRequest
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	r.RequestID = raw.RequestID
	if raw.Result != nil {
		value, err := unmarshalQueuedCommandResult(raw.Result)
		if err != nil {
			return err
		}
		r.Result = value
	}
	return nil
}

func (r EventLogTypes) MarshalJSON() ([]byte, error) {
	if r.String != nil {
		return json.Marshal(r.String)
	}
	if r.StringArray != nil {
		return json.Marshal(r.StringArray)
	}
	return []byte("null"), nil
}

func (r *EventLogTypes) UnmarshalJSON(data []byte) error {
	if string(data) == "null" {
		*r = EventLogTypes{}
		return nil
	}
	{
		var value EventLogTypesString
		if err := json.Unmarshal(data, &value); err == nil {
			*r = EventLogTypes{String: &value}
			return nil
		}
	}
	{
		var value []string
		if err := json.Unmarshal(data, &value); err == nil {
			*r = EventLogTypes{StringArray: value}
			return nil
		}
	}
	return errors.New("data did not match any union variant for EventLogTypes")
}

func unmarshalExternalToolTextResultForLlmContent(data []byte) (ExternalToolTextResultForLlmContent, error) {
	if string(data) == "null" {
		return nil, nil
	}
	type rawUnion struct {
		Type ExternalToolTextResultForLlmContentType `json:"type"`
	}
	var raw rawUnion
	if err := json.Unmarshal(data, &raw); err != nil {
		return nil, err
	}

	switch raw.Type {
	case ExternalToolTextResultForLlmContentTypeAudio:
		var d ExternalToolTextResultForLlmContentAudio
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case ExternalToolTextResultForLlmContentTypeImage:
		var d ExternalToolTextResultForLlmContentImage
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case ExternalToolTextResultForLlmContentTypeResource:
		var d ExternalToolTextResultForLlmContentResource
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case ExternalToolTextResultForLlmContentTypeResourceLink:
		var d ExternalToolTextResultForLlmContentResourceLink
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case ExternalToolTextResultForLlmContentTypeTerminal:
		var d ExternalToolTextResultForLlmContentTerminal
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case ExternalToolTextResultForLlmContentTypeText:
		var d ExternalToolTextResultForLlmContentText
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	default:
		return &RawExternalToolTextResultForLlmContentData{Discriminator: raw.Type, Raw: data}, nil
	}
}

func (r RawExternalToolTextResultForLlmContentData) MarshalJSON() ([]byte, error) {
	if r.Raw != nil {
		return r.Raw, nil
	}
	return json.Marshal(struct {
		Type ExternalToolTextResultForLlmContentType `json:"type"`
	}{
		Type: r.Discriminator,
	})
}

func (r ExternalToolTextResultForLlmContentAudio) MarshalJSON() ([]byte, error) {
	type alias ExternalToolTextResultForLlmContentAudio
	return json.Marshal(struct {
		Type ExternalToolTextResultForLlmContentType `json:"type"`
		alias
	}{
		Type:  r.Type(),
		alias: alias(r),
	})
}

func (r ExternalToolTextResultForLlmContentImage) MarshalJSON() ([]byte, error) {
	type alias ExternalToolTextResultForLlmContentImage
	return json.Marshal(struct {
		Type ExternalToolTextResultForLlmContentType `json:"type"`
		alias
	}{
		Type:  r.Type(),
		alias: alias(r),
	})
}

func matchesEmbeddedBlobResourceContents(data []byte) bool {
	var rawGroup0 struct {
		Blob json.RawMessage `json:"blob"`
		Text json.RawMessage `json:"text"`
	}
	if err := json.Unmarshal(data, &rawGroup0); err != nil {
		return false
	}
	if rawGroup0.Blob == nil {
		return false
	}
	return rawGroup0.Text == nil
}

func matchesEmbeddedTextResourceContents(data []byte) bool {
	var rawGroup0 struct {
		Blob json.RawMessage `json:"blob"`
		Text json.RawMessage `json:"text"`
	}
	if err := json.Unmarshal(data, &rawGroup0); err != nil {
		return false
	}
	if rawGroup0.Text == nil {
		return false
	}
	return rawGroup0.Blob == nil
}

func unmarshalExternalToolTextResultForLlmContentResourceDetails(data []byte) (ExternalToolTextResultForLlmContentResourceDetails, error) {
	if string(data) == "null" {
		return nil, nil
	}
	if matchesEmbeddedBlobResourceContents(data) {
		var d EmbeddedBlobResourceContents
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	}
	if matchesEmbeddedTextResourceContents(data) {
		var d EmbeddedTextResourceContents
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	}
	return &RawExternalToolTextResultForLlmContentResourceDetailsData{Raw: data}, nil
}

func (r RawExternalToolTextResultForLlmContentResourceDetailsData) MarshalJSON() ([]byte, error) {
	if r.Raw != nil {
		return r.Raw, nil
	}
	return []byte("null"), nil
}

func (r *ExternalToolTextResultForLlmContentResource) UnmarshalJSON(data []byte) error {
	type rawExternalToolTextResultForLlmContentResource struct {
		Resource json.RawMessage `json:"resource"`
	}
	var raw rawExternalToolTextResultForLlmContentResource
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	if raw.Resource != nil {
		value, err := unmarshalExternalToolTextResultForLlmContentResourceDetails(raw.Resource)
		if err != nil {
			return err
		}
		r.Resource = value
	}
	return nil
}

func (r ExternalToolTextResultForLlmContentResource) MarshalJSON() ([]byte, error) {
	type alias ExternalToolTextResultForLlmContentResource
	return json.Marshal(struct {
		Type ExternalToolTextResultForLlmContentType `json:"type"`
		alias
	}{
		Type:  r.Type(),
		alias: alias(r),
	})
}

func (r ExternalToolTextResultForLlmContentResourceLink) MarshalJSON() ([]byte, error) {
	type alias ExternalToolTextResultForLlmContentResourceLink
	return json.Marshal(struct {
		Type ExternalToolTextResultForLlmContentType `json:"type"`
		alias
	}{
		Type:  r.Type(),
		alias: alias(r),
	})
}

func (r ExternalToolTextResultForLlmContentTerminal) MarshalJSON() ([]byte, error) {
	type alias ExternalToolTextResultForLlmContentTerminal
	return json.Marshal(struct {
		Type ExternalToolTextResultForLlmContentType `json:"type"`
		alias
	}{
		Type:  r.Type(),
		alias: alias(r),
	})
}

func (r ExternalToolTextResultForLlmContentText) MarshalJSON() ([]byte, error) {
	type alias ExternalToolTextResultForLlmContentText
	return json.Marshal(struct {
		Type ExternalToolTextResultForLlmContentType `json:"type"`
		alias
	}{
		Type:  r.Type(),
		alias: alias(r),
	})
}

func (r *ExternalToolTextResultForLlm) UnmarshalJSON(data []byte) error {
	type rawExternalToolTextResultForLlm struct {
		BinaryResultsForLlm []ExternalToolTextResultForLlmBinaryResultsForLlm `json:"binaryResultsForLlm,omitempty"`
		Contents            []json.RawMessage                                 `json:"contents,omitempty"`
		Error               *string                                           `json:"error,omitempty"`
		ResultType          *string                                           `json:"resultType,omitempty"`
		SessionLog          *string                                           `json:"sessionLog,omitempty"`
		TextResultForLlm    string                                            `json:"textResultForLlm"`
		ToolTelemetry       map[string]any                                    `json:"toolTelemetry,omitempty"`
	}
	var raw rawExternalToolTextResultForLlm
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	r.BinaryResultsForLlm = raw.BinaryResultsForLlm
	if raw.Contents != nil {
		r.Contents = make([]ExternalToolTextResultForLlmContent, 0, len(raw.Contents))
		for _, rawItem := range raw.Contents {
			value, err := unmarshalExternalToolTextResultForLlmContent(rawItem)
			if err != nil {
				return err
			}
			r.Contents = append(r.Contents, value)
		}
	}
	r.Error = raw.Error
	r.ResultType = raw.ResultType
	r.SessionLog = raw.SessionLog
	r.TextResultForLlm = raw.TextResultForLlm
	r.ToolTelemetry = raw.ToolTelemetry
	return nil
}

func unmarshalExternalToolResult(data []byte) (ExternalToolResult, error) {
	if string(data) == "null" {
		return nil, nil
	}
	{
		var value string
		if err := json.Unmarshal(data, &value); err == nil {
			return ExternalToolStringResult(value), nil
		}
	}
	{
		var value ExternalToolTextResultForLlm
		if err := json.Unmarshal(data, &value); err == nil {
			return &value, nil
		}
	}
	return nil, errors.New("data did not match any union variant for ExternalToolResult")
}

func unmarshalFilterMapping(data []byte) (FilterMapping, error) {
	if string(data) == "null" {
		return nil, nil
	}
	{
		var value FilterMappingEnumMap
		if err := json.Unmarshal(data, &value); err == nil {
			return value, nil
		}
	}
	{
		var value ContentFilterMode
		if err := json.Unmarshal(data, &value); err == nil {
			return value, nil
		}
	}
	return nil, errors.New("data did not match any union variant for FilterMapping")
}

func (r *HandlePendingToolCallRequest) UnmarshalJSON(data []byte) error {
	type rawHandlePendingToolCallRequest struct {
		Error     *string         `json:"error,omitempty"`
		RequestID string          `json:"requestId"`
		Result    json.RawMessage `json:"result,omitempty"`
	}
	var raw rawHandlePendingToolCallRequest
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	r.Error = raw.Error
	r.RequestID = raw.RequestID
	if raw.Result != nil {
		value, err := unmarshalExternalToolResult(raw.Result)
		if err != nil {
			return err
		}
		r.Result = value
	}
	return nil
}

func (r InstalledPluginSource) MarshalJSON() ([]byte, error) {
	if r.InstalledPluginSourceGithub != nil {
		return json.Marshal(r.InstalledPluginSourceGithub)
	}
	if r.InstalledPluginSourceLocal != nil {
		return json.Marshal(r.InstalledPluginSourceLocal)
	}
	if r.InstalledPluginSourceURL != nil {
		return json.Marshal(r.InstalledPluginSourceURL)
	}
	if r.String != nil {
		return json.Marshal(r.String)
	}
	return []byte("null"), nil
}

func (r *InstalledPluginSource) UnmarshalJSON(data []byte) error {
	if string(data) == "null" {
		*r = InstalledPluginSource{}
		return nil
	}
	{
		var value InstalledPluginSourceGithub
		if err := json.Unmarshal(data, &value); err == nil {
			*r = InstalledPluginSource{InstalledPluginSourceGithub: &value}
			return nil
		}
	}
	{
		var value InstalledPluginSourceLocal
		if err := json.Unmarshal(data, &value); err == nil {
			*r = InstalledPluginSource{InstalledPluginSourceLocal: &value}
			return nil
		}
	}
	{
		var value InstalledPluginSourceURL
		if err := json.Unmarshal(data, &value); err == nil {
			*r = InstalledPluginSource{InstalledPluginSourceURL: &value}
			return nil
		}
	}
	{
		var value string
		if err := json.Unmarshal(data, &value); err == nil {
			*r = InstalledPluginSource{String: &value}
			return nil
		}
	}
	return errors.New("data did not match any union variant for InstalledPluginSource")
}

func matchesMcpServerConfigHTTP(data []byte) bool {
	var rawGroup0 struct {
		Command json.RawMessage `json:"command"`
		URL     json.RawMessage `json:"url"`
	}
	if err := json.Unmarshal(data, &rawGroup0); err != nil {
		return false
	}
	if rawGroup0.URL == nil {
		return false
	}
	return rawGroup0.Command == nil
}

func matchesMcpServerConfigStdio(data []byte) bool {
	var rawGroup0 struct {
		Command json.RawMessage `json:"command"`
		URL     json.RawMessage `json:"url"`
	}
	if err := json.Unmarshal(data, &rawGroup0); err != nil {
		return false
	}
	if rawGroup0.Command == nil {
		return false
	}
	return rawGroup0.URL == nil
}

func unmarshalMcpServerConfig(data []byte) (McpServerConfig, error) {
	if string(data) == "null" {
		return nil, nil
	}
	if matchesMcpServerConfigHTTP(data) {
		var d McpServerConfigHTTP
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	}
	if matchesMcpServerConfigStdio(data) {
		var d McpServerConfigStdio
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	}
	return &RawMcpServerConfigData{Raw: data}, nil
}

func (r RawMcpServerConfigData) MarshalJSON() ([]byte, error) {
	if r.Raw != nil {
		return r.Raw, nil
	}
	return []byte("null"), nil
}

func (r *McpServerConfigHTTP) UnmarshalJSON(data []byte) error {
	type rawMcpServerConfigHTTP struct {
		Auth              *McpServerConfigHTTPAuth           `json:"auth,omitempty"`
		FilterMapping     json.RawMessage                    `json:"filterMapping,omitempty"`
		Headers           map[string]string                  `json:"headers,omitempty"`
		IsDefaultServer   *bool                              `json:"isDefaultServer,omitempty"`
		OauthClientID     *string                            `json:"oauthClientId,omitempty"`
		OauthGrantType    *McpServerConfigHTTPOauthGrantType `json:"oauthGrantType,omitempty"`
		OauthPublicClient *bool                              `json:"oauthPublicClient,omitempty"`
		Timeout           *int64                             `json:"timeout,omitempty"`
		Tools             []string                           `json:"tools,omitempty"`
		Type              *McpServerConfigHTTPType           `json:"type,omitempty"`
		URL               string                             `json:"url"`
	}
	var raw rawMcpServerConfigHTTP
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	r.Auth = raw.Auth
	if raw.FilterMapping != nil {
		value, err := unmarshalFilterMapping(raw.FilterMapping)
		if err != nil {
			return err
		}
		r.FilterMapping = value
	}
	r.Headers = raw.Headers
	r.IsDefaultServer = raw.IsDefaultServer
	r.OauthClientID = raw.OauthClientID
	r.OauthGrantType = raw.OauthGrantType
	r.OauthPublicClient = raw.OauthPublicClient
	r.Timeout = raw.Timeout
	r.Tools = raw.Tools
	r.Type = raw.Type
	r.URL = raw.URL
	return nil
}

func (r *McpServerConfigStdio) UnmarshalJSON(data []byte) error {
	type rawMcpServerConfigStdio struct {
		Args            []string          `json:"args,omitempty"`
		Command         string            `json:"command"`
		Cwd             *string           `json:"cwd,omitempty"`
		Env             map[string]string `json:"env,omitempty"`
		FilterMapping   json.RawMessage   `json:"filterMapping,omitempty"`
		IsDefaultServer *bool             `json:"isDefaultServer,omitempty"`
		Timeout         *int64            `json:"timeout,omitempty"`
		Tools           []string          `json:"tools,omitempty"`
	}
	var raw rawMcpServerConfigStdio
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	r.Args = raw.Args
	r.Command = raw.Command
	r.Cwd = raw.Cwd
	r.Env = raw.Env
	if raw.FilterMapping != nil {
		value, err := unmarshalFilterMapping(raw.FilterMapping)
		if err != nil {
			return err
		}
		r.FilterMapping = value
	}
	r.IsDefaultServer = raw.IsDefaultServer
	r.Timeout = raw.Timeout
	r.Tools = raw.Tools
	return nil
}

func (r *McpConfigAddRequest) UnmarshalJSON(data []byte) error {
	type rawMcpConfigAddRequest struct {
		Config json.RawMessage `json:"config"`
		Name   string          `json:"name"`
	}
	var raw rawMcpConfigAddRequest
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	if raw.Config != nil {
		value, err := unmarshalMcpServerConfig(raw.Config)
		if err != nil {
			return err
		}
		r.Config = value
	}
	r.Name = raw.Name
	return nil
}

func (r *McpConfigList) UnmarshalJSON(data []byte) error {
	type rawMcpConfigList struct {
		Servers map[string]json.RawMessage `json:"servers"`
	}
	var raw rawMcpConfigList
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	if raw.Servers != nil {
		r.Servers = make(map[string]McpServerConfig, len(raw.Servers))
		for key, rawValue := range raw.Servers {
			value, err := unmarshalMcpServerConfig(rawValue)
			if err != nil {
				return err
			}
			r.Servers[key] = value
		}
	}
	return nil
}

func (r *McpConfigUpdateRequest) UnmarshalJSON(data []byte) error {
	type rawMcpConfigUpdateRequest struct {
		Config json.RawMessage `json:"config"`
		Name   string          `json:"name"`
	}
	var raw rawMcpConfigUpdateRequest
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	if raw.Config != nil {
		value, err := unmarshalMcpServerConfig(raw.Config)
		if err != nil {
			return err
		}
		r.Config = value
	}
	r.Name = raw.Name
	return nil
}

func unmarshalPermissionDecision(data []byte) (PermissionDecision, error) {
	if string(data) == "null" {
		return nil, nil
	}
	type rawUnion struct {
		Kind PermissionDecisionKind `json:"kind"`
	}
	var raw rawUnion
	if err := json.Unmarshal(data, &raw); err != nil {
		return nil, err
	}

	switch raw.Kind {
	case PermissionDecisionKindApproveForLocation:
		var d PermissionDecisionApproveForLocation
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionDecisionKindApproveForSession:
		var d PermissionDecisionApproveForSession
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionDecisionKindApproveOnce:
		var d PermissionDecisionApproveOnce
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionDecisionKindApprovePermanently:
		var d PermissionDecisionApprovePermanently
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionDecisionKindApproved:
		var d PermissionDecisionApproved
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionDecisionKindApprovedForLocation:
		var d PermissionDecisionApprovedForLocation
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionDecisionKindApprovedForSession:
		var d PermissionDecisionApprovedForSession
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionDecisionKindCancelled:
		var d PermissionDecisionCancelled
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionDecisionKindDeniedByContentExclusionPolicy:
		var d PermissionDecisionDeniedByContentExclusionPolicy
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionDecisionKindDeniedByPermissionRequestHook:
		var d PermissionDecisionDeniedByPermissionRequestHook
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionDecisionKindDeniedByRules:
		var d PermissionDecisionDeniedByRules
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionDecisionKindDeniedInteractivelyByUser:
		var d PermissionDecisionDeniedInteractivelyByUser
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionDecisionKindDeniedNoApprovalRuleAndCouldNotRequestFromUser:
		var d PermissionDecisionDeniedNoApprovalRuleAndCouldNotRequestFromUser
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionDecisionKindReject:
		var d PermissionDecisionReject
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionDecisionKindUserNotAvailable:
		var d PermissionDecisionUserNotAvailable
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	default:
		return &RawPermissionDecisionData{Discriminator: raw.Kind, Raw: data}, nil
	}
}

func (r RawPermissionDecisionData) MarshalJSON() ([]byte, error) {
	if r.Raw != nil {
		return r.Raw, nil
	}
	return json.Marshal(struct {
		Kind PermissionDecisionKind `json:"kind"`
	}{
		Kind: r.Discriminator,
	})
}

func (r PermissionDecisionApproved) MarshalJSON() ([]byte, error) {
	type alias PermissionDecisionApproved
	return json.Marshal(struct {
		Kind PermissionDecisionKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		alias: alias(r),
	})
}

func unmarshalUserToolSessionApproval(data []byte) (UserToolSessionApproval, error) {
	if string(data) == "null" {
		return nil, nil
	}
	type rawUnion struct {
		Kind UserToolSessionApprovalKind `json:"kind"`
	}
	var raw rawUnion
	if err := json.Unmarshal(data, &raw); err != nil {
		return nil, err
	}

	switch raw.Kind {
	case UserToolSessionApprovalKindCommands:
		var d UserToolSessionApprovalCommands
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case UserToolSessionApprovalKindCustomTool:
		var d UserToolSessionApprovalCustomTool
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case UserToolSessionApprovalKindExtensionManagement:
		var d UserToolSessionApprovalExtensionManagement
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case UserToolSessionApprovalKindExtensionPermissionAccess:
		var d UserToolSessionApprovalExtensionPermissionAccess
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case UserToolSessionApprovalKindMcp:
		var d UserToolSessionApprovalMcp
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case UserToolSessionApprovalKindMemory:
		var d UserToolSessionApprovalMemory
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case UserToolSessionApprovalKindRead:
		var d UserToolSessionApprovalRead
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case UserToolSessionApprovalKindWrite:
		var d UserToolSessionApprovalWrite
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	default:
		return &RawUserToolSessionApprovalData{Discriminator: raw.Kind, Raw: data}, nil
	}
}

func (r RawUserToolSessionApprovalData) MarshalJSON() ([]byte, error) {
	if r.Raw != nil {
		return r.Raw, nil
	}
	return json.Marshal(struct {
		Kind UserToolSessionApprovalKind `json:"kind"`
	}{
		Kind: r.Discriminator,
	})
}

func (r UserToolSessionApprovalCommands) MarshalJSON() ([]byte, error) {
	type alias UserToolSessionApprovalCommands
	return json.Marshal(struct {
		Kind UserToolSessionApprovalKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		alias: alias(r),
	})
}

func (r UserToolSessionApprovalCustomTool) MarshalJSON() ([]byte, error) {
	type alias UserToolSessionApprovalCustomTool
	return json.Marshal(struct {
		Kind UserToolSessionApprovalKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		alias: alias(r),
	})
}

func (r UserToolSessionApprovalExtensionManagement) MarshalJSON() ([]byte, error) {
	type alias UserToolSessionApprovalExtensionManagement
	return json.Marshal(struct {
		Kind UserToolSessionApprovalKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		alias: alias(r),
	})
}

func (r UserToolSessionApprovalExtensionPermissionAccess) MarshalJSON() ([]byte, error) {
	type alias UserToolSessionApprovalExtensionPermissionAccess
	return json.Marshal(struct {
		Kind UserToolSessionApprovalKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		alias: alias(r),
	})
}

func (r UserToolSessionApprovalMcp) MarshalJSON() ([]byte, error) {
	type alias UserToolSessionApprovalMcp
	return json.Marshal(struct {
		Kind UserToolSessionApprovalKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		alias: alias(r),
	})
}

func (r UserToolSessionApprovalMemory) MarshalJSON() ([]byte, error) {
	type alias UserToolSessionApprovalMemory
	return json.Marshal(struct {
		Kind UserToolSessionApprovalKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		alias: alias(r),
	})
}

func (r UserToolSessionApprovalRead) MarshalJSON() ([]byte, error) {
	type alias UserToolSessionApprovalRead
	return json.Marshal(struct {
		Kind UserToolSessionApprovalKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		alias: alias(r),
	})
}

func (r UserToolSessionApprovalWrite) MarshalJSON() ([]byte, error) {
	type alias UserToolSessionApprovalWrite
	return json.Marshal(struct {
		Kind UserToolSessionApprovalKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		alias: alias(r),
	})
}

func (r *PermissionDecisionApprovedForLocation) UnmarshalJSON(data []byte) error {
	type rawPermissionDecisionApprovedForLocation struct {
		Approval    json.RawMessage `json:"approval"`
		LocationKey string          `json:"locationKey"`
	}
	var raw rawPermissionDecisionApprovedForLocation
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	if raw.Approval != nil {
		value, err := unmarshalUserToolSessionApproval(raw.Approval)
		if err != nil {
			return err
		}
		r.Approval = value
	}
	r.LocationKey = raw.LocationKey
	return nil
}

func (r PermissionDecisionApprovedForLocation) MarshalJSON() ([]byte, error) {
	type alias PermissionDecisionApprovedForLocation
	return json.Marshal(struct {
		Kind PermissionDecisionKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		alias: alias(r),
	})
}

func (r *PermissionDecisionApprovedForSession) UnmarshalJSON(data []byte) error {
	type rawPermissionDecisionApprovedForSession struct {
		Approval json.RawMessage `json:"approval"`
	}
	var raw rawPermissionDecisionApprovedForSession
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	if raw.Approval != nil {
		value, err := unmarshalUserToolSessionApproval(raw.Approval)
		if err != nil {
			return err
		}
		r.Approval = value
	}
	return nil
}

func (r PermissionDecisionApprovedForSession) MarshalJSON() ([]byte, error) {
	type alias PermissionDecisionApprovedForSession
	return json.Marshal(struct {
		Kind PermissionDecisionKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		alias: alias(r),
	})
}

func unmarshalPermissionDecisionApproveForLocationApproval(data []byte) (PermissionDecisionApproveForLocationApproval, error) {
	if string(data) == "null" {
		return nil, nil
	}
	type rawUnion struct {
		Kind PermissionDecisionApproveForLocationApprovalKind `json:"kind"`
	}
	var raw rawUnion
	if err := json.Unmarshal(data, &raw); err != nil {
		return nil, err
	}

	switch raw.Kind {
	case PermissionDecisionApproveForLocationApprovalKindCommands:
		var d PermissionDecisionApproveForLocationApprovalCommands
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionDecisionApproveForLocationApprovalKindCustomTool:
		var d PermissionDecisionApproveForLocationApprovalCustomTool
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionDecisionApproveForLocationApprovalKindExtensionManagement:
		var d PermissionDecisionApproveForLocationApprovalExtensionManagement
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionDecisionApproveForLocationApprovalKindExtensionPermissionAccess:
		var d PermissionDecisionApproveForLocationApprovalExtensionPermissionAccess
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionDecisionApproveForLocationApprovalKindMcp:
		var d PermissionDecisionApproveForLocationApprovalMcp
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionDecisionApproveForLocationApprovalKindMcpSampling:
		var d PermissionDecisionApproveForLocationApprovalMcpSampling
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionDecisionApproveForLocationApprovalKindMemory:
		var d PermissionDecisionApproveForLocationApprovalMemory
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionDecisionApproveForLocationApprovalKindRead:
		var d PermissionDecisionApproveForLocationApprovalRead
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionDecisionApproveForLocationApprovalKindWrite:
		var d PermissionDecisionApproveForLocationApprovalWrite
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	default:
		return &RawPermissionDecisionApproveForLocationApprovalData{Discriminator: raw.Kind, Raw: data}, nil
	}
}

func (r RawPermissionDecisionApproveForLocationApprovalData) MarshalJSON() ([]byte, error) {
	if r.Raw != nil {
		return r.Raw, nil
	}
	return json.Marshal(struct {
		Kind PermissionDecisionApproveForLocationApprovalKind `json:"kind"`
	}{
		Kind: r.Discriminator,
	})
}

func (r PermissionDecisionApproveForLocationApprovalCommands) MarshalJSON() ([]byte, error) {
	type alias PermissionDecisionApproveForLocationApprovalCommands
	return json.Marshal(struct {
		Kind PermissionDecisionApproveForLocationApprovalKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		alias: alias(r),
	})
}

func (r PermissionDecisionApproveForLocationApprovalCustomTool) MarshalJSON() ([]byte, error) {
	type alias PermissionDecisionApproveForLocationApprovalCustomTool
	return json.Marshal(struct {
		Kind PermissionDecisionApproveForLocationApprovalKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		alias: alias(r),
	})
}

func (r PermissionDecisionApproveForLocationApprovalExtensionManagement) MarshalJSON() ([]byte, error) {
	type alias PermissionDecisionApproveForLocationApprovalExtensionManagement
	return json.Marshal(struct {
		Kind PermissionDecisionApproveForLocationApprovalKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		alias: alias(r),
	})
}

func (r PermissionDecisionApproveForLocationApprovalExtensionPermissionAccess) MarshalJSON() ([]byte, error) {
	type alias PermissionDecisionApproveForLocationApprovalExtensionPermissionAccess
	return json.Marshal(struct {
		Kind PermissionDecisionApproveForLocationApprovalKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		alias: alias(r),
	})
}

func (r PermissionDecisionApproveForLocationApprovalMcp) MarshalJSON() ([]byte, error) {
	type alias PermissionDecisionApproveForLocationApprovalMcp
	return json.Marshal(struct {
		Kind PermissionDecisionApproveForLocationApprovalKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		alias: alias(r),
	})
}

func (r PermissionDecisionApproveForLocationApprovalMcpSampling) MarshalJSON() ([]byte, error) {
	type alias PermissionDecisionApproveForLocationApprovalMcpSampling
	return json.Marshal(struct {
		Kind PermissionDecisionApproveForLocationApprovalKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		alias: alias(r),
	})
}

func (r PermissionDecisionApproveForLocationApprovalMemory) MarshalJSON() ([]byte, error) {
	type alias PermissionDecisionApproveForLocationApprovalMemory
	return json.Marshal(struct {
		Kind PermissionDecisionApproveForLocationApprovalKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		alias: alias(r),
	})
}

func (r PermissionDecisionApproveForLocationApprovalRead) MarshalJSON() ([]byte, error) {
	type alias PermissionDecisionApproveForLocationApprovalRead
	return json.Marshal(struct {
		Kind PermissionDecisionApproveForLocationApprovalKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		alias: alias(r),
	})
}

func (r PermissionDecisionApproveForLocationApprovalWrite) MarshalJSON() ([]byte, error) {
	type alias PermissionDecisionApproveForLocationApprovalWrite
	return json.Marshal(struct {
		Kind PermissionDecisionApproveForLocationApprovalKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		alias: alias(r),
	})
}

func (r *PermissionDecisionApproveForLocation) UnmarshalJSON(data []byte) error {
	type rawPermissionDecisionApproveForLocation struct {
		Approval    json.RawMessage `json:"approval"`
		LocationKey string          `json:"locationKey"`
	}
	var raw rawPermissionDecisionApproveForLocation
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	if raw.Approval != nil {
		value, err := unmarshalPermissionDecisionApproveForLocationApproval(raw.Approval)
		if err != nil {
			return err
		}
		r.Approval = value
	}
	r.LocationKey = raw.LocationKey
	return nil
}

func (r PermissionDecisionApproveForLocation) MarshalJSON() ([]byte, error) {
	type alias PermissionDecisionApproveForLocation
	return json.Marshal(struct {
		Kind PermissionDecisionKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		alias: alias(r),
	})
}

func unmarshalPermissionDecisionApproveForSessionApproval(data []byte) (PermissionDecisionApproveForSessionApproval, error) {
	if string(data) == "null" {
		return nil, nil
	}
	type rawUnion struct {
		Kind PermissionDecisionApproveForSessionApprovalKind `json:"kind"`
	}
	var raw rawUnion
	if err := json.Unmarshal(data, &raw); err != nil {
		return nil, err
	}

	switch raw.Kind {
	case PermissionDecisionApproveForSessionApprovalKindCommands:
		var d PermissionDecisionApproveForSessionApprovalCommands
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionDecisionApproveForSessionApprovalKindCustomTool:
		var d PermissionDecisionApproveForSessionApprovalCustomTool
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionDecisionApproveForSessionApprovalKindExtensionManagement:
		var d PermissionDecisionApproveForSessionApprovalExtensionManagement
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionDecisionApproveForSessionApprovalKindExtensionPermissionAccess:
		var d PermissionDecisionApproveForSessionApprovalExtensionPermissionAccess
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionDecisionApproveForSessionApprovalKindMcp:
		var d PermissionDecisionApproveForSessionApprovalMcp
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionDecisionApproveForSessionApprovalKindMcpSampling:
		var d PermissionDecisionApproveForSessionApprovalMcpSampling
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionDecisionApproveForSessionApprovalKindMemory:
		var d PermissionDecisionApproveForSessionApprovalMemory
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionDecisionApproveForSessionApprovalKindRead:
		var d PermissionDecisionApproveForSessionApprovalRead
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionDecisionApproveForSessionApprovalKindWrite:
		var d PermissionDecisionApproveForSessionApprovalWrite
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	default:
		return &RawPermissionDecisionApproveForSessionApprovalData{Discriminator: raw.Kind, Raw: data}, nil
	}
}

func (r RawPermissionDecisionApproveForSessionApprovalData) MarshalJSON() ([]byte, error) {
	if r.Raw != nil {
		return r.Raw, nil
	}
	return json.Marshal(struct {
		Kind PermissionDecisionApproveForSessionApprovalKind `json:"kind"`
	}{
		Kind: r.Discriminator,
	})
}

func (r PermissionDecisionApproveForSessionApprovalCommands) MarshalJSON() ([]byte, error) {
	type alias PermissionDecisionApproveForSessionApprovalCommands
	return json.Marshal(struct {
		Kind PermissionDecisionApproveForSessionApprovalKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		alias: alias(r),
	})
}

func (r PermissionDecisionApproveForSessionApprovalCustomTool) MarshalJSON() ([]byte, error) {
	type alias PermissionDecisionApproveForSessionApprovalCustomTool
	return json.Marshal(struct {
		Kind PermissionDecisionApproveForSessionApprovalKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		alias: alias(r),
	})
}

func (r PermissionDecisionApproveForSessionApprovalExtensionManagement) MarshalJSON() ([]byte, error) {
	type alias PermissionDecisionApproveForSessionApprovalExtensionManagement
	return json.Marshal(struct {
		Kind PermissionDecisionApproveForSessionApprovalKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		alias: alias(r),
	})
}

func (r PermissionDecisionApproveForSessionApprovalExtensionPermissionAccess) MarshalJSON() ([]byte, error) {
	type alias PermissionDecisionApproveForSessionApprovalExtensionPermissionAccess
	return json.Marshal(struct {
		Kind PermissionDecisionApproveForSessionApprovalKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		alias: alias(r),
	})
}

func (r PermissionDecisionApproveForSessionApprovalMcp) MarshalJSON() ([]byte, error) {
	type alias PermissionDecisionApproveForSessionApprovalMcp
	return json.Marshal(struct {
		Kind PermissionDecisionApproveForSessionApprovalKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		alias: alias(r),
	})
}

func (r PermissionDecisionApproveForSessionApprovalMcpSampling) MarshalJSON() ([]byte, error) {
	type alias PermissionDecisionApproveForSessionApprovalMcpSampling
	return json.Marshal(struct {
		Kind PermissionDecisionApproveForSessionApprovalKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		alias: alias(r),
	})
}

func (r PermissionDecisionApproveForSessionApprovalMemory) MarshalJSON() ([]byte, error) {
	type alias PermissionDecisionApproveForSessionApprovalMemory
	return json.Marshal(struct {
		Kind PermissionDecisionApproveForSessionApprovalKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		alias: alias(r),
	})
}

func (r PermissionDecisionApproveForSessionApprovalRead) MarshalJSON() ([]byte, error) {
	type alias PermissionDecisionApproveForSessionApprovalRead
	return json.Marshal(struct {
		Kind PermissionDecisionApproveForSessionApprovalKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		alias: alias(r),
	})
}

func (r PermissionDecisionApproveForSessionApprovalWrite) MarshalJSON() ([]byte, error) {
	type alias PermissionDecisionApproveForSessionApprovalWrite
	return json.Marshal(struct {
		Kind PermissionDecisionApproveForSessionApprovalKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		alias: alias(r),
	})
}

func (r *PermissionDecisionApproveForSession) UnmarshalJSON(data []byte) error {
	type rawPermissionDecisionApproveForSession struct {
		Approval json.RawMessage `json:"approval,omitempty"`
		Domain   *string         `json:"domain,omitempty"`
	}
	var raw rawPermissionDecisionApproveForSession
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	if raw.Approval != nil {
		value, err := unmarshalPermissionDecisionApproveForSessionApproval(raw.Approval)
		if err != nil {
			return err
		}
		r.Approval = value
	}
	r.Domain = raw.Domain
	return nil
}

func (r PermissionDecisionApproveForSession) MarshalJSON() ([]byte, error) {
	type alias PermissionDecisionApproveForSession
	return json.Marshal(struct {
		Kind PermissionDecisionKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		alias: alias(r),
	})
}

func (r PermissionDecisionApproveOnce) MarshalJSON() ([]byte, error) {
	type alias PermissionDecisionApproveOnce
	return json.Marshal(struct {
		Kind PermissionDecisionKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		alias: alias(r),
	})
}

func (r PermissionDecisionApprovePermanently) MarshalJSON() ([]byte, error) {
	type alias PermissionDecisionApprovePermanently
	return json.Marshal(struct {
		Kind PermissionDecisionKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		alias: alias(r),
	})
}

func (r PermissionDecisionCancelled) MarshalJSON() ([]byte, error) {
	type alias PermissionDecisionCancelled
	return json.Marshal(struct {
		Kind PermissionDecisionKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		alias: alias(r),
	})
}

func (r PermissionDecisionDeniedByContentExclusionPolicy) MarshalJSON() ([]byte, error) {
	type alias PermissionDecisionDeniedByContentExclusionPolicy
	return json.Marshal(struct {
		Kind PermissionDecisionKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		alias: alias(r),
	})
}

func (r PermissionDecisionDeniedByPermissionRequestHook) MarshalJSON() ([]byte, error) {
	type alias PermissionDecisionDeniedByPermissionRequestHook
	return json.Marshal(struct {
		Kind PermissionDecisionKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		alias: alias(r),
	})
}

func (r PermissionDecisionDeniedByRules) MarshalJSON() ([]byte, error) {
	type alias PermissionDecisionDeniedByRules
	return json.Marshal(struct {
		Kind PermissionDecisionKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		alias: alias(r),
	})
}

func (r PermissionDecisionDeniedInteractivelyByUser) MarshalJSON() ([]byte, error) {
	type alias PermissionDecisionDeniedInteractivelyByUser
	return json.Marshal(struct {
		Kind PermissionDecisionKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		alias: alias(r),
	})
}

func (r PermissionDecisionDeniedNoApprovalRuleAndCouldNotRequestFromUser) MarshalJSON() ([]byte, error) {
	type alias PermissionDecisionDeniedNoApprovalRuleAndCouldNotRequestFromUser
	return json.Marshal(struct {
		Kind PermissionDecisionKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		alias: alias(r),
	})
}

func (r PermissionDecisionReject) MarshalJSON() ([]byte, error) {
	type alias PermissionDecisionReject
	return json.Marshal(struct {
		Kind PermissionDecisionKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		alias: alias(r),
	})
}

func (r PermissionDecisionUserNotAvailable) MarshalJSON() ([]byte, error) {
	type alias PermissionDecisionUserNotAvailable
	return json.Marshal(struct {
		Kind PermissionDecisionKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		alias: alias(r),
	})
}

func (r *PermissionDecisionRequest) UnmarshalJSON(data []byte) error {
	type rawPermissionDecisionRequest struct {
		RequestID string          `json:"requestId"`
		Result    json.RawMessage `json:"result"`
	}
	var raw rawPermissionDecisionRequest
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	r.RequestID = raw.RequestID
	if raw.Result != nil {
		value, err := unmarshalPermissionDecision(raw.Result)
		if err != nil {
			return err
		}
		r.Result = value
	}
	return nil
}

func unmarshalSendAttachment(data []byte) (SendAttachment, error) {
	if string(data) == "null" {
		return nil, nil
	}
	type rawUnion struct {
		Type SendAttachmentType `json:"type"`
	}
	var raw rawUnion
	if err := json.Unmarshal(data, &raw); err != nil {
		return nil, err
	}

	switch raw.Type {
	case SendAttachmentTypeBlob:
		var d SendAttachmentBlob
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case SendAttachmentTypeDirectory:
		var d SendAttachmentDirectory
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case SendAttachmentTypeFile:
		var d SendAttachmentFile
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case SendAttachmentTypeGithubReference:
		var d SendAttachmentGithubReference
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case SendAttachmentTypeSelection:
		var d SendAttachmentSelection
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	default:
		return &RawSendAttachmentData{Discriminator: raw.Type, Raw: data}, nil
	}
}

func (r RawSendAttachmentData) MarshalJSON() ([]byte, error) {
	if r.Raw != nil {
		return r.Raw, nil
	}
	return json.Marshal(struct {
		Type SendAttachmentType `json:"type"`
	}{
		Type: r.Discriminator,
	})
}

func (r SendAttachmentBlob) MarshalJSON() ([]byte, error) {
	type alias SendAttachmentBlob
	return json.Marshal(struct {
		Type SendAttachmentType `json:"type"`
		alias
	}{
		Type:  r.Type(),
		alias: alias(r),
	})
}

func (r SendAttachmentDirectory) MarshalJSON() ([]byte, error) {
	type alias SendAttachmentDirectory
	return json.Marshal(struct {
		Type SendAttachmentType `json:"type"`
		alias
	}{
		Type:  r.Type(),
		alias: alias(r),
	})
}

func (r SendAttachmentFile) MarshalJSON() ([]byte, error) {
	type alias SendAttachmentFile
	return json.Marshal(struct {
		Type SendAttachmentType `json:"type"`
		alias
	}{
		Type:  r.Type(),
		alias: alias(r),
	})
}

func (r SendAttachmentGithubReference) MarshalJSON() ([]byte, error) {
	type alias SendAttachmentGithubReference
	return json.Marshal(struct {
		Type SendAttachmentType `json:"type"`
		alias
	}{
		Type:  r.Type(),
		alias: alias(r),
	})
}

func (r SendAttachmentSelection) MarshalJSON() ([]byte, error) {
	type alias SendAttachmentSelection
	return json.Marshal(struct {
		Type SendAttachmentType `json:"type"`
		alias
	}{
		Type:  r.Type(),
		alias: alias(r),
	})
}

func (r *SendRequest) UnmarshalJSON(data []byte) error {
	type rawSendRequest struct {
		AgentMode      *SendAgentMode    `json:"agentMode,omitempty"`
		Attachments    []json.RawMessage `json:"attachments,omitempty"`
		Billable       *bool             `json:"billable,omitempty"`
		DisplayPrompt  *string           `json:"displayPrompt,omitempty"`
		Mode           *SendMode         `json:"mode,omitempty"`
		Prepend        *bool             `json:"prepend,omitempty"`
		Prompt         string            `json:"prompt"`
		RequestHeaders map[string]string `json:"requestHeaders,omitempty"`
		RequiredTool   *string           `json:"requiredTool,omitempty"`
		Source         any               `json:"source,omitempty"`
		Traceparent    *string           `json:"traceparent,omitempty"`
		Tracestate     *string           `json:"tracestate,omitempty"`
		Wait           *bool             `json:"wait,omitempty"`
	}
	var raw rawSendRequest
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	r.AgentMode = raw.AgentMode
	if raw.Attachments != nil {
		r.Attachments = make([]SendAttachment, 0, len(raw.Attachments))
		for _, rawItem := range raw.Attachments {
			value, err := unmarshalSendAttachment(rawItem)
			if err != nil {
				return err
			}
			r.Attachments = append(r.Attachments, value)
		}
	}
	r.Billable = raw.Billable
	r.DisplayPrompt = raw.DisplayPrompt
	r.Mode = raw.Mode
	r.Prepend = raw.Prepend
	r.Prompt = raw.Prompt
	r.RequestHeaders = raw.RequestHeaders
	r.RequiredTool = raw.RequiredTool
	r.Source = raw.Source
	r.Traceparent = raw.Traceparent
	r.Tracestate = raw.Tracestate
	r.Wait = raw.Wait
	return nil
}

func (r SessionInstalledPluginSource) MarshalJSON() ([]byte, error) {
	if r.SessionInstalledPluginSourceGithub != nil {
		return json.Marshal(r.SessionInstalledPluginSourceGithub)
	}
	if r.SessionInstalledPluginSourceLocal != nil {
		return json.Marshal(r.SessionInstalledPluginSourceLocal)
	}
	if r.SessionInstalledPluginSourceURL != nil {
		return json.Marshal(r.SessionInstalledPluginSourceURL)
	}
	if r.String != nil {
		return json.Marshal(r.String)
	}
	return []byte("null"), nil
}

func (r *SessionInstalledPluginSource) UnmarshalJSON(data []byte) error {
	if string(data) == "null" {
		*r = SessionInstalledPluginSource{}
		return nil
	}
	{
		var value SessionInstalledPluginSourceGithub
		if err := json.Unmarshal(data, &value); err == nil {
			*r = SessionInstalledPluginSource{SessionInstalledPluginSourceGithub: &value}
			return nil
		}
	}
	{
		var value SessionInstalledPluginSourceLocal
		if err := json.Unmarshal(data, &value); err == nil {
			*r = SessionInstalledPluginSource{SessionInstalledPluginSourceLocal: &value}
			return nil
		}
	}
	{
		var value SessionInstalledPluginSourceURL
		if err := json.Unmarshal(data, &value); err == nil {
			*r = SessionInstalledPluginSource{SessionInstalledPluginSourceURL: &value}
			return nil
		}
	}
	{
		var value string
		if err := json.Unmarshal(data, &value); err == nil {
			*r = SessionInstalledPluginSource{String: &value}
			return nil
		}
	}
	return errors.New("data did not match any union variant for SessionInstalledPluginSource")
}

func (r *SessionSetCredentialsParams) UnmarshalJSON(data []byte) error {
	type rawSessionSetCredentialsParams struct {
		Credentials json.RawMessage `json:"credentials,omitempty"`
	}
	var raw rawSessionSetCredentialsParams
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	if raw.Credentials != nil {
		value, err := unmarshalAuthInfo(raw.Credentials)
		if err != nil {
			return err
		}
		r.Credentials = value
	}
	return nil
}

func unmarshalSlashCommandInvocationResult(data []byte) (SlashCommandInvocationResult, error) {
	if string(data) == "null" {
		return nil, nil
	}
	type rawUnion struct {
		Kind SlashCommandInvocationResultKind `json:"kind"`
	}
	var raw rawUnion
	if err := json.Unmarshal(data, &raw); err != nil {
		return nil, err
	}

	switch raw.Kind {
	case SlashCommandInvocationResultKindAgentPrompt:
		var d SlashCommandAgentPromptResult
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case SlashCommandInvocationResultKindCompleted:
		var d SlashCommandCompletedResult
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case SlashCommandInvocationResultKindSelectSubcommand:
		var d SlashCommandSelectSubcommandResult
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case SlashCommandInvocationResultKindText:
		var d SlashCommandTextResult
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	default:
		return &RawSlashCommandInvocationResultData{Discriminator: raw.Kind, Raw: data}, nil
	}
}

func (r RawSlashCommandInvocationResultData) MarshalJSON() ([]byte, error) {
	if r.Raw != nil {
		return r.Raw, nil
	}
	return json.Marshal(struct {
		Kind SlashCommandInvocationResultKind `json:"kind"`
	}{
		Kind: r.Discriminator,
	})
}

func (r SlashCommandAgentPromptResult) MarshalJSON() ([]byte, error) {
	type alias SlashCommandAgentPromptResult
	return json.Marshal(struct {
		Kind SlashCommandInvocationResultKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		alias: alias(r),
	})
}

func (r SlashCommandCompletedResult) MarshalJSON() ([]byte, error) {
	type alias SlashCommandCompletedResult
	return json.Marshal(struct {
		Kind SlashCommandInvocationResultKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		alias: alias(r),
	})
}

func (r SlashCommandSelectSubcommandResult) MarshalJSON() ([]byte, error) {
	type alias SlashCommandSelectSubcommandResult
	return json.Marshal(struct {
		Kind SlashCommandInvocationResultKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		alias: alias(r),
	})
}

func (r SlashCommandTextResult) MarshalJSON() ([]byte, error) {
	type alias SlashCommandTextResult
	return json.Marshal(struct {
		Kind SlashCommandInvocationResultKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		alias: alias(r),
	})
}

func unmarshalTaskAgentProgress(data []byte) (TaskAgentProgress, error) {
	if string(data) == "null" {
		return nil, nil
	}
	type rawUnion struct {
		Type TaskAgentProgressType `json:"type"`
	}
	var raw rawUnion
	if err := json.Unmarshal(data, &raw); err != nil {
		return nil, err
	}

	switch raw.Type {
	case TaskAgentProgressTypeAgent:
		var d TaskAgentProgressAgent
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case TaskAgentProgressTypeShell:
		var d TaskAgentProgressShell
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	default:
		return &RawTaskAgentProgressData{Discriminator: raw.Type, Raw: data}, nil
	}
}

func (r RawTaskAgentProgressData) MarshalJSON() ([]byte, error) {
	if r.Raw != nil {
		return r.Raw, nil
	}
	return json.Marshal(struct {
		Type TaskAgentProgressType `json:"type"`
	}{
		Type: r.Discriminator,
	})
}

func (r TaskAgentProgressAgent) MarshalJSON() ([]byte, error) {
	type alias TaskAgentProgressAgent
	return json.Marshal(struct {
		Type TaskAgentProgressType `json:"type"`
		alias
	}{
		Type:  r.Type(),
		alias: alias(r),
	})
}

func (r TaskAgentProgressShell) MarshalJSON() ([]byte, error) {
	type alias TaskAgentProgressShell
	return json.Marshal(struct {
		Type TaskAgentProgressType `json:"type"`
		alias
	}{
		Type:  r.Type(),
		alias: alias(r),
	})
}

func unmarshalTaskInfo(data []byte) (TaskInfo, error) {
	if string(data) == "null" {
		return nil, nil
	}
	type rawUnion struct {
		Type TaskInfoType `json:"type"`
	}
	var raw rawUnion
	if err := json.Unmarshal(data, &raw); err != nil {
		return nil, err
	}

	switch raw.Type {
	case TaskInfoTypeAgent:
		var d TaskAgentInfo
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case TaskInfoTypeShell:
		var d TaskShellInfo
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	default:
		return &RawTaskInfoData{Discriminator: raw.Type, Raw: data}, nil
	}
}

func (r RawTaskInfoData) MarshalJSON() ([]byte, error) {
	if r.Raw != nil {
		return r.Raw, nil
	}
	return json.Marshal(struct {
		Type TaskInfoType `json:"type"`
	}{
		Type: r.Discriminator,
	})
}

func (r TaskAgentInfo) MarshalJSON() ([]byte, error) {
	type alias TaskAgentInfo
	return json.Marshal(struct {
		Type TaskInfoType `json:"type"`
		alias
	}{
		Type:  r.Type(),
		alias: alias(r),
	})
}

func (r TaskShellInfo) MarshalJSON() ([]byte, error) {
	type alias TaskShellInfo
	return json.Marshal(struct {
		Type TaskInfoType `json:"type"`
		alias
	}{
		Type:  r.Type(),
		alias: alias(r),
	})
}

func (r *TaskList) UnmarshalJSON(data []byte) error {
	type rawTaskList struct {
		Tasks []json.RawMessage `json:"tasks"`
	}
	var raw rawTaskList
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	if raw.Tasks != nil {
		r.Tasks = make([]TaskInfo, 0, len(raw.Tasks))
		for _, rawItem := range raw.Tasks {
			value, err := unmarshalTaskInfo(rawItem)
			if err != nil {
				return err
			}
			r.Tasks = append(r.Tasks, value)
		}
	}
	return nil
}

func (r TaskProgress) MarshalJSON() ([]byte, error) {
	if r.TaskAgentProgress != nil {
		return json.Marshal(r.TaskAgentProgress)
	}
	if r.TaskShellProgress != nil {
		return json.Marshal(r.TaskShellProgress)
	}
	return []byte("null"), nil
}

func (r *TaskProgress) UnmarshalJSON(data []byte) error {
	if string(data) == "null" {
		*r = TaskProgress{}
		return nil
	}
	{
		value, err := unmarshalTaskAgentProgress(data)
		if err == nil {
			*r = TaskProgress{TaskAgentProgress: value}
			return nil
		}
	}
	{
		var value any
		if err := json.Unmarshal(data, &value); err == nil {
			*r = TaskProgress{TaskShellProgress: &value}
			return nil
		}
	}
	return errors.New("data did not match any union variant for TaskProgress")
}

func (r *TasksGetCurrentPromotableResult) UnmarshalJSON(data []byte) error {
	type rawTasksGetCurrentPromotableResult struct {
		Task json.RawMessage `json:"task,omitempty"`
	}
	var raw rawTasksGetCurrentPromotableResult
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	if raw.Task != nil {
		value, err := unmarshalTaskInfo(raw.Task)
		if err != nil {
			return err
		}
		r.Task = value
	}
	return nil
}

func (r *TasksPromoteCurrentToBackgroundResult) UnmarshalJSON(data []byte) error {
	type rawTasksPromoteCurrentToBackgroundResult struct {
		Task json.RawMessage `json:"task,omitempty"`
	}
	var raw rawTasksPromoteCurrentToBackgroundResult
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	if raw.Task != nil {
		value, err := unmarshalTaskInfo(raw.Task)
		if err != nil {
			return err
		}
		r.Task = value
	}
	return nil
}

func unmarshalUIElicitationFieldValue(data []byte) (UIElicitationFieldValue, error) {
	if string(data) == "null" {
		return nil, nil
	}
	{
		var value string
		if err := json.Unmarshal(data, &value); err == nil {
			return UIElicitationStringValue(value), nil
		}
	}
	{
		var value float64
		if err := json.Unmarshal(data, &value); err == nil {
			return UIElicitationNumberValue(value), nil
		}
	}
	{
		var value bool
		if err := json.Unmarshal(data, &value); err == nil {
			return UIElicitationBooleanValue(value), nil
		}
	}
	{
		var value []string
		if err := json.Unmarshal(data, &value); err == nil {
			return UIElicitationStringArrayValue(value), nil
		}
	}
	return nil, errors.New("data did not match any union variant for UIElicitationFieldValue")
}

func matchesUIElicitationArrayAnyOfField(data []byte) bool {
	var rawGroup0 struct {
		Items json.RawMessage `json:"items"`
	}
	if err := json.Unmarshal(data, &rawGroup0); err != nil {
		return false
	}
	if rawGroup0.Items == nil {
		return false
	}
	var rawGroup0Items struct {
		AnyOf json.RawMessage `json:"anyOf"`
		Enum  json.RawMessage `json:"enum"`
		Type  json.RawMessage `json:"type"`
	}
	if err := json.Unmarshal(rawGroup0.Items, &rawGroup0Items); err != nil {
		return false
	}
	if rawGroup0Items.AnyOf == nil {
		return false
	}
	if rawGroup0Items.Enum != nil {
		return false
	}
	return rawGroup0Items.Type == nil
}

func matchesUIElicitationArrayEnumField(data []byte) bool {
	var rawGroup0 struct {
		Items json.RawMessage `json:"items"`
	}
	if err := json.Unmarshal(data, &rawGroup0); err != nil {
		return false
	}
	if rawGroup0.Items == nil {
		return false
	}
	var rawGroup0Items struct {
		AnyOf json.RawMessage `json:"anyOf"`
		Enum  json.RawMessage `json:"enum"`
		Type  json.RawMessage `json:"type"`
	}
	if err := json.Unmarshal(rawGroup0.Items, &rawGroup0Items); err != nil {
		return false
	}
	if rawGroup0Items.Enum == nil {
		return false
	}
	if rawGroup0Items.Type == nil {
		return false
	}
	var rawGroup0String string
	if err := json.Unmarshal(rawGroup0Items.Type, &rawGroup0String); err != nil {
		return false
	}
	switch rawGroup0String {
	case "string":
	default:
		return false
	}
	return rawGroup0Items.AnyOf == nil
}

func matchesUIElicitationSchemaPropertyString(data []byte) bool {
	var rawGroup0 struct {
		Enum  json.RawMessage `json:"enum"`
		OneOf json.RawMessage `json:"oneOf"`
	}
	if err := json.Unmarshal(data, &rawGroup0); err != nil {
		return false
	}
	if rawGroup0.Enum != nil {
		return false
	}
	return rawGroup0.OneOf == nil
}

func matchesUIElicitationStringEnumField(data []byte) bool {
	var rawGroup0 struct {
		Enum  json.RawMessage `json:"enum"`
		OneOf json.RawMessage `json:"oneOf"`
	}
	if err := json.Unmarshal(data, &rawGroup0); err != nil {
		return false
	}
	if rawGroup0.Enum == nil {
		return false
	}
	return rawGroup0.OneOf == nil
}

func matchesUIElicitationStringOneOfField(data []byte) bool {
	var rawGroup0 struct {
		Enum  json.RawMessage `json:"enum"`
		OneOf json.RawMessage `json:"oneOf"`
	}
	if err := json.Unmarshal(data, &rawGroup0); err != nil {
		return false
	}
	if rawGroup0.OneOf == nil {
		return false
	}
	return rawGroup0.Enum == nil
}

func unmarshalUIElicitationSchemaProperty(data []byte) (UIElicitationSchemaProperty, error) {
	if string(data) == "null" {
		return nil, nil
	}
	type rawUnion struct {
		Type UIElicitationSchemaPropertyType `json:"type"`
	}
	var raw rawUnion
	if err := json.Unmarshal(data, &raw); err != nil {
		return nil, err
	}

	switch raw.Type {
	case UIElicitationSchemaPropertyTypeArray:
		if matchesUIElicitationArrayAnyOfField(data) {
			var d UIElicitationArrayAnyOfField
			if err := json.Unmarshal(data, &d); err != nil {
				return nil, err
			}
			return &d, nil
		}
		if matchesUIElicitationArrayEnumField(data) {
			var d UIElicitationArrayEnumField
			if err := json.Unmarshal(data, &d); err != nil {
				return nil, err
			}
			return &d, nil
		}
		return &RawUIElicitationSchemaPropertyData{Discriminator: raw.Type, Raw: data}, nil
	case UIElicitationSchemaPropertyTypeBoolean:
		var d UIElicitationSchemaPropertyBoolean
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case UIElicitationSchemaPropertyTypeInteger:
		var d UIElicitationSchemaPropertyNumber
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case UIElicitationSchemaPropertyTypeNumber:
		var d UIElicitationSchemaPropertyNumber
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case UIElicitationSchemaPropertyTypeString:
		if matchesUIElicitationSchemaPropertyString(data) {
			var d UIElicitationSchemaPropertyString
			if err := json.Unmarshal(data, &d); err != nil {
				return nil, err
			}
			return &d, nil
		}
		if matchesUIElicitationStringEnumField(data) {
			var d UIElicitationStringEnumField
			if err := json.Unmarshal(data, &d); err != nil {
				return nil, err
			}
			return &d, nil
		}
		if matchesUIElicitationStringOneOfField(data) {
			var d UIElicitationStringOneOfField
			if err := json.Unmarshal(data, &d); err != nil {
				return nil, err
			}
			return &d, nil
		}
		return &RawUIElicitationSchemaPropertyData{Discriminator: raw.Type, Raw: data}, nil
	default:
		return &RawUIElicitationSchemaPropertyData{Discriminator: raw.Type, Raw: data}, nil
	}
}

func (r RawUIElicitationSchemaPropertyData) MarshalJSON() ([]byte, error) {
	if r.Raw != nil {
		return r.Raw, nil
	}
	return json.Marshal(struct {
		Type UIElicitationSchemaPropertyType `json:"type"`
	}{
		Type: r.Discriminator,
	})
}

func (r UIElicitationArrayAnyOfField) MarshalJSON() ([]byte, error) {
	type alias UIElicitationArrayAnyOfField
	return json.Marshal(struct {
		Type UIElicitationSchemaPropertyType `json:"type"`
		alias
	}{
		Type:  r.Type(),
		alias: alias(r),
	})
}

func (r UIElicitationArrayEnumField) MarshalJSON() ([]byte, error) {
	type alias UIElicitationArrayEnumField
	return json.Marshal(struct {
		Type UIElicitationSchemaPropertyType `json:"type"`
		alias
	}{
		Type:  r.Type(),
		alias: alias(r),
	})
}

func (r UIElicitationSchemaPropertyBoolean) MarshalJSON() ([]byte, error) {
	type alias UIElicitationSchemaPropertyBoolean
	return json.Marshal(struct {
		Type UIElicitationSchemaPropertyType `json:"type"`
		alias
	}{
		Type:  r.Type(),
		alias: alias(r),
	})
}

func (r UIElicitationSchemaPropertyNumber) MarshalJSON() ([]byte, error) {
	type alias UIElicitationSchemaPropertyNumber
	return json.Marshal(struct {
		Type UIElicitationSchemaPropertyType `json:"type"`
		alias
	}{
		Type:  r.Type(),
		alias: alias(r),
	})
}

func (r UIElicitationSchemaPropertyString) MarshalJSON() ([]byte, error) {
	type alias UIElicitationSchemaPropertyString
	return json.Marshal(struct {
		Type UIElicitationSchemaPropertyType `json:"type"`
		alias
	}{
		Type:  r.Type(),
		alias: alias(r),
	})
}

func (r UIElicitationStringEnumField) MarshalJSON() ([]byte, error) {
	type alias UIElicitationStringEnumField
	return json.Marshal(struct {
		Type UIElicitationSchemaPropertyType `json:"type"`
		alias
	}{
		Type:  r.Type(),
		alias: alias(r),
	})
}

func (r UIElicitationStringOneOfField) MarshalJSON() ([]byte, error) {
	type alias UIElicitationStringOneOfField
	return json.Marshal(struct {
		Type UIElicitationSchemaPropertyType `json:"type"`
		alias
	}{
		Type:  r.Type(),
		alias: alias(r),
	})
}

func (r *UIElicitationSchema) UnmarshalJSON(data []byte) error {
	type rawUIElicitationSchema struct {
		Properties map[string]json.RawMessage `json:"properties"`
		Required   []string                   `json:"required,omitempty"`
		Type       UIElicitationSchemaType    `json:"type"`
	}
	var raw rawUIElicitationSchema
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	if raw.Properties != nil {
		r.Properties = make(map[string]UIElicitationSchemaProperty, len(raw.Properties))
		for key, rawValue := range raw.Properties {
			value, err := unmarshalUIElicitationSchemaProperty(rawValue)
			if err != nil {
				return err
			}
			r.Properties[key] = value
		}
	}
	r.Required = raw.Required
	r.Type = raw.Type
	return nil
}

func (r *UIElicitationResponse) UnmarshalJSON(data []byte) error {
	type rawUIElicitationResponse struct {
		Action  UIElicitationResponseAction `json:"action"`
		Content map[string]json.RawMessage  `json:"content,omitempty"`
	}
	var raw rawUIElicitationResponse
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	r.Action = raw.Action
	if raw.Content != nil {
		r.Content = make(map[string]UIElicitationFieldValue, len(raw.Content))
		for key, rawValue := range raw.Content {
			value, err := unmarshalUIElicitationFieldValue(rawValue)
			if err != nil {
				return err
			}
			r.Content[key] = value
		}
	}
	return nil
}