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 AuthInfoTypeTokenProvider:
		var d TokenProviderAuthInfo
		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 TokenProviderAuthInfo) MarshalJSON() ([]byte, error) {
	type alias TokenProviderAuthInfo
	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 (r *AccountAllUsers) UnmarshalJSON(data []byte) error {
	type rawAccountAllUsers struct {
		AuthInfo    json.RawMessage `json:"authInfo"`
		SelectionID *string         `json:"selectionId,omitempty"`
		Token       *string         `json:"token,omitempty"`
	}
	var raw rawAccountAllUsers
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	if raw.AuthInfo != nil {
		value, err := unmarshalAuthInfo(raw.AuthInfo)
		if err != nil {
			return err
		}
		r.AuthInfo = value
	}
	r.SelectionID = raw.SelectionID
	r.Token = raw.Token
	return nil
}

func (r *AccountGetCurrentAuthResult) UnmarshalJSON(data []byte) error {
	type rawAccountGetCurrentAuthResult struct {
		AuthErrors []string        `json:"authErrors,omitzero"`
		AuthInfo   json.RawMessage `json:"authInfo,omitempty"`
	}
	var raw rawAccountGetCurrentAuthResult
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	r.AuthErrors = raw.AuthErrors
	if raw.AuthInfo != nil {
		value, err := unmarshalAuthInfo(raw.AuthInfo)
		if err != nil {
			return err
		}
		r.AuthInfo = value
	}
	return nil
}

func (r *AccountLogoutRequest) UnmarshalJSON(data []byte) error {
	type rawAccountLogoutRequest struct {
		AuthInfo    json.RawMessage `json:"authInfo,omitempty"`
		SelectionID *string         `json:"selectionId,omitempty"`
	}
	var raw rawAccountLogoutRequest
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	if raw.AuthInfo != nil {
		value, err := unmarshalAuthInfo(raw.AuthInfo)
		if err != nil {
			return err
		}
		r.AuthInfo = value
	}
	r.SelectionID = raw.SelectionID
	return nil
}

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

	switch raw.Kind {
	case AgentRegistrySpawnResultKindRegistryTimeout:
		var d AgentRegistrySpawnRegistryTimeout
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case AgentRegistrySpawnResultKindSpawnError:
		var d AgentRegistrySpawnError
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case AgentRegistrySpawnResultKindSpawned:
		var d AgentRegistrySpawnSpawned
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case AgentRegistrySpawnResultKindValidationError:
		var d AgentRegistrySpawnValidationError
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	default:
		return &RawAgentRegistrySpawnResultData{Discriminator: raw.Kind, Raw: data}, nil
	}
}

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

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

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

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

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

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

	switch raw.Type {
	case AttachmentTypeBlob:
		var d AttachmentBlob
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case AttachmentTypeDirectory:
		var d AttachmentDirectory
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case AttachmentTypeExtensionContext:
		var d AttachmentExtensionContext
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case AttachmentTypeFile:
		var d AttachmentFile
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case AttachmentTypeGitHubActionsJob:
		var d AttachmentGitHubActionsJob
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case AttachmentTypeGitHubCommit:
		var d AttachmentGitHubCommit
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case AttachmentTypeGitHubFile:
		var d AttachmentGitHubFile
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case AttachmentTypeGitHubFileDiff:
		var d AttachmentGitHubFileDiff
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case AttachmentTypeGitHubReference:
		var d AttachmentGitHubReference
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case AttachmentTypeGitHubRelease:
		var d AttachmentGitHubRelease
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case AttachmentTypeGitHubRepository:
		var d AttachmentGitHubRepository
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case AttachmentTypeGitHubSnippet:
		var d AttachmentGitHubSnippet
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case AttachmentTypeGitHubTreeComparison:
		var d AttachmentGitHubTreeComparison
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case AttachmentTypeGitHubURL:
		var d AttachmentGitHubURL
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case AttachmentTypeSelection:
		var d AttachmentSelection
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	default:
		return &RawAttachmentData{Discriminator: raw.Type, Raw: data}, nil
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (r *BuiltinToolDescriptor) UnmarshalJSON(data []byte) error {
	type rawBuiltinToolDescriptor struct {
		Description           string                  `json:"description"`
		Format                *BuiltinToolFormat      `json:"format"`
		HasSummariseIntention bool                    `json:"hasSummariseIntention"`
		InputSchema           *BuiltinToolInputSchema `json:"inputSchema"`
		Instructions          *string                 `json:"instructions"`
		IsTerminal            bool                    `json:"isTerminal"`
		Name                  string                  `json:"name"`
		SafeForTelemetry      json.RawMessage         `json:"safeForTelemetry"`
		Title                 *string                 `json:"title"`
		Type                  *string                 `json:"type"`
	}
	var raw rawBuiltinToolDescriptor
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	r.Description = raw.Description
	r.Format = raw.Format
	r.HasSummariseIntention = raw.HasSummariseIntention
	r.InputSchema = raw.InputSchema
	r.Instructions = raw.Instructions
	r.IsTerminal = raw.IsTerminal
	r.Name = raw.Name
	if raw.SafeForTelemetry != nil {
		value, err := unmarshalBuiltinToolSafeForTelemetry(raw.SafeForTelemetry)
		if err != nil {
			return err
		}
		r.SafeForTelemetry = value
	}
	r.Title = raw.Title
	r.Type = raw.Type
	return nil
}

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

	switch raw.Kind {
	case CatalogCandidateKindAiSkill:
		var d CatalogAiSkillCandidate
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case CatalogCandidateKindMCPServer:
		var d CatalogMCPServerCandidate
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	default:
		return &RawCatalogCandidateData{Discriminator: raw.Kind, Raw: data}, nil
	}
}

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

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

	switch raw.Kind {
	case CatalogCandidateSourceKindEmbedded:
		var d CatalogCandidateSourceEmbedded
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case CatalogCandidateSourceKindURL:
		var d CatalogCandidateSourceURL
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	default:
		return &RawCatalogCandidateSourceData{Discriminator: raw.Kind, Raw: data}, nil
	}
}

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

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

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

func (r *CatalogAiSkillCandidate) UnmarshalJSON(data []byte) error {
	type rawCatalogAiSkillCandidate struct {
		Description     *string                               `json:"description,omitempty"`
		DisplayName     string                                `json:"displayName"`
		Handle          string                                `json:"handle"`
		HandleExpiresAt string                                `json:"handleExpiresAt"`
		Installability  CatalogAiSkillCandidateInstallability `json:"installability"`
		MediaType       CatalogAiSkillCandidateMediaType      `json:"mediaType"`
		Provenance      CatalogAiSkillCandidateProvenance     `json:"provenance"`
		Publisher       *string                               `json:"publisher,omitempty"`
		Source          json.RawMessage                       `json:"source"`
	}
	var raw rawCatalogAiSkillCandidate
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	r.Description = raw.Description
	r.DisplayName = raw.DisplayName
	r.Handle = raw.Handle
	r.HandleExpiresAt = raw.HandleExpiresAt
	r.Installability = raw.Installability
	r.MediaType = raw.MediaType
	r.Provenance = raw.Provenance
	r.Publisher = raw.Publisher
	if raw.Source != nil {
		value, err := unmarshalCatalogCandidateSource(raw.Source)
		if err != nil {
			return err
		}
		r.Source = value
	}
	return nil
}

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

func (r *CatalogMCPServerCandidate) UnmarshalJSON(data []byte) error {
	type rawCatalogMCPServerCandidate struct {
		Description     *string                             `json:"description,omitempty"`
		DisplayName     string                              `json:"displayName"`
		Handle          string                              `json:"handle"`
		HandleExpiresAt string                              `json:"handleExpiresAt"`
		Installability  CatalogMCPServerInstallability      `json:"installability"`
		MediaType       MCPServerCardMediaType              `json:"mediaType"`
		Provenance      CatalogMCPServerCandidateProvenance `json:"provenance"`
		Publisher       *string                             `json:"publisher,omitempty"`
		Source          json.RawMessage                     `json:"source"`
	}
	var raw rawCatalogMCPServerCandidate
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	r.Description = raw.Description
	r.DisplayName = raw.DisplayName
	r.Handle = raw.Handle
	r.HandleExpiresAt = raw.HandleExpiresAt
	r.Installability = raw.Installability
	r.MediaType = raw.MediaType
	r.Provenance = raw.Provenance
	r.Publisher = raw.Publisher
	if raw.Source != nil {
		value, err := unmarshalCatalogCandidateSource(raw.Source)
		if err != nil {
			return err
		}
		r.Source = value
	}
	return nil
}

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

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

	switch raw.Kind {
	case CatalogSearchResultKindAuthenticationRequired:
		var d CatalogAuthenticationRequiredError
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case CatalogSearchResultKindContractViolation:
		var d CatalogContractViolationError
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case CatalogSearchResultKindInvalidRequest:
		var d CatalogInvalidRequestError
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case CatalogSearchResultKindMalformedCard:
		var d CatalogMalformedCardError
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case CatalogSearchResultKindNegotiationRefused:
		var d CatalogNegotiationRefusedError
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case CatalogSearchResultKindNetworkFailure:
		var d CatalogNetworkFailureError
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case CatalogSearchResultKindPolicyRejected:
		var d CatalogPolicyRejectedError
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case CatalogSearchResultKindSucceeded:
		var d CatalogSearchSucceeded
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case CatalogSearchResultKindUnavailable:
		var d CatalogUnavailableError
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case CatalogSearchResultKindUnsafeRetrieval:
		var d CatalogUnsafeRetrievalError
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case CatalogSearchResultKindUnsupportedKind:
		var d CatalogUnsupportedKindError
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	default:
		return &RawCatalogSearchResultData{Discriminator: raw.Kind, Raw: data}, nil
	}
}

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

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

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

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

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

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

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

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

func (r *CatalogSearchSucceeded) UnmarshalJSON(data []byte) error {
	type rawCatalogSearchSucceeded struct {
		Candidates []json.RawMessage         `json:"candidates"`
		Negotiated CatalogNegotiatedContract `json:"negotiated"`
		SearchID   string                    `json:"searchId"`
		Truncated  bool                      `json:"truncated"`
	}
	var raw rawCatalogSearchSucceeded
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	if raw.Candidates != nil {
		r.Candidates = make([]CatalogCandidate, 0, len(raw.Candidates))
		for _, rawItem := range raw.Candidates {
			value, err := unmarshalCatalogCandidate(rawItem)
			if err != nil {
				return err
			}
			r.Candidates = append(r.Candidates, value)
		}
	}
	r.Negotiated = raw.Negotiated
	r.SearchID = raw.SearchID
	r.Truncated = raw.Truncated
	return nil
}

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

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

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

func (r CatalogUnsupportedKindError) MarshalJSON() ([]byte, error) {
	type alias CatalogUnsupportedKindError
	return json.Marshal(struct {
		Kind CatalogSearchResultKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		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 unmarshalDebugCollectLogsDestination(data []byte) (DebugCollectLogsDestination, error) {
	if string(data) == "null" {
		return nil, nil
	}
	type rawUnion struct {
		Kind DebugCollectLogsDestinationKind `json:"kind"`
	}
	var raw rawUnion
	if err := json.Unmarshal(data, &raw); err != nil {
		return nil, err
	}

	switch raw.Kind {
	case DebugCollectLogsDestinationKindArchive:
		var d DebugCollectLogsDestinationArchive
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case DebugCollectLogsDestinationKindDirectory:
		var d DebugCollectLogsDestinationDirectory
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	default:
		return &RawDebugCollectLogsDestinationData{Discriminator: raw.Kind, Raw: data}, nil
	}
}

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

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

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

func (r *DebugCollectLogsRequest) UnmarshalJSON(data []byte) error {
	type rawDebugCollectLogsRequest struct {
		AdditionalEntries []DebugCollectLogsEntry  `json:"additionalEntries,omitzero"`
		Destination       json.RawMessage          `json:"destination"`
		Include           *DebugCollectLogsInclude `json:"include,omitempty"`
	}
	var raw rawDebugCollectLogsRequest
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	r.AdditionalEntries = raw.AdditionalEntries
	if raw.Destination != nil {
		value, err := unmarshalDebugCollectLogsDestination(raw.Destination)
		if err != nil {
			return err
		}
		r.Destination = value
	}
	r.Include = raw.Include
	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 ExternalToolTextResultForLlmContentTypeShellExit:
		var d ExternalToolTextResultForLlmContentShellExit
		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 matchesExternalToolTextResultForLlmContentResourceDetailsEmbeddedBlobResourceContents(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 matchesExternalToolTextResultForLlmContentResourceDetailsEmbeddedTextResourceContents(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 matchesExternalToolTextResultForLlmContentResourceDetailsEmbeddedBlobResourceContents(data) {
		var d EmbeddedBlobResourceContents
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	}
	if matchesExternalToolTextResultForLlmContentResourceDetailsEmbeddedTextResourceContents(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 ExternalToolTextResultForLlmContentShellExit) MarshalJSON() ([]byte, error) {
	type alias ExternalToolTextResultForLlmContentShellExit
	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,omitzero"`
		Contents            []json.RawMessage                                 `json:"contents,omitzero"`
		Error               *string                                           `json:"error,omitempty"`
		ResultType          *string                                           `json:"resultType,omitempty"`
		SessionLog          *string                                           `json:"sessionLog,omitempty"`
		TextResultForLlm    string                                            `json:"textResultForLlm"`
		ToolReferences      []string                                          `json:"toolReferences,omitzero"`
		ToolTelemetry       map[string]any                                    `json:"toolTelemetry,omitzero"`
	}
	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.ToolReferences = raw.ToolReferences
	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 unmarshalFactoryRunFailure(data []byte) (FactoryRunFailure, error) {
	if string(data) == "null" {
		return nil, nil
	}
	type rawUnion struct {
		Type FactoryRunFailureType `json:"type"`
	}
	var raw rawUnion
	if err := json.Unmarshal(data, &raw); err != nil {
		return nil, err
	}

	switch raw.Type {
	case FactoryRunFailureTypeFactoryAccountingIncomplete:
		var d FactoryRunFailureFactoryAccountingIncomplete
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case FactoryRunFailureTypeFactoryDurableFailure:
		var d FactoryRunFailureFactoryDurableFailure
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case FactoryRunFailureTypeFactoryLimitReached:
		var d FactoryRunFailureFactoryLimitReached
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case FactoryRunFailureTypeFactoryProviderDisconnected:
		var d FactoryRunFailureFactoryProviderDisconnected
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case FactoryRunFailureTypeFactoryResumeDeclined:
		var d FactoryRunFailureFactoryResumeDeclined
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	default:
		return &RawFactoryRunFailureData{Discriminator: raw.Type, Raw: data}, nil
	}
}

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

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

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

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

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

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

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

	switch raw.Type {
	case FactoryPauseInfoTypeCheckpoint:
		var d FactoryPauseInfoCheckpoint
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case FactoryPauseInfoTypeUser:
		var d FactoryPauseInfoUser
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	default:
		return &RawFactoryPauseInfoData{Discriminator: raw.Type, Raw: data}, nil
	}
}

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

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

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

func (r *FactoryRunTerminal) UnmarshalJSON(data []byte) error {
	type rawFactoryRunTerminal struct {
		Error         *string         `json:"error,omitempty"`
		Failure       json.RawMessage `json:"failure,omitempty"`
		PauseInfo     json.RawMessage `json:"pauseInfo"`
		Reason        *string         `json:"reason,omitempty"`
		ResultPreview *string         `json:"resultPreview,omitempty"`
	}
	var raw rawFactoryRunTerminal
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	r.Error = raw.Error
	if raw.Failure != nil {
		value, err := unmarshalFactoryRunFailure(raw.Failure)
		if err != nil {
			return err
		}
		r.Failure = value
	}
	if raw.PauseInfo != nil {
		value, err := unmarshalFactoryPauseInfo(raw.PauseInfo)
		if err != nil {
			return err
		}
		r.PauseInfo = value
	}
	r.Reason = raw.Reason
	r.ResultPreview = raw.ResultPreview
	return nil
}

func (r *FactoryRunResult) UnmarshalJSON(data []byte) error {
	type rawFactoryRunResult struct {
		Attempt   *int64           `json:"attempt,omitempty"`
		Error     *string          `json:"error,omitempty"`
		Failure   json.RawMessage  `json:"failure,omitempty"`
		PauseInfo json.RawMessage  `json:"pauseInfo,omitempty"`
		Reason    *string          `json:"reason,omitempty"`
		Result    any              `json:"result,omitempty"`
		RunID     string           `json:"runId"`
		Snapshot  any              `json:"snapshot,omitempty"`
		Status    FactoryRunStatus `json:"status"`
	}
	var raw rawFactoryRunResult
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	r.Attempt = raw.Attempt
	r.Error = raw.Error
	if raw.Failure != nil {
		value, err := unmarshalFactoryRunFailure(raw.Failure)
		if err != nil {
			return err
		}
		r.Failure = value
	}
	if raw.PauseInfo != nil {
		value, err := unmarshalFactoryPauseInfo(raw.PauseInfo)
		if err != nil {
			return err
		}
		r.PauseInfo = value
	}
	r.Reason = raw.Reason
	r.Result = raw.Result
	r.RunID = raw.RunID
	r.Snapshot = raw.Snapshot
	r.Status = raw.Status
	return nil
}

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 unmarshalGitHubTokenAcquireResult(data []byte) (GitHubTokenAcquireResult, error) {
	if string(data) == "null" {
		return nil, nil
	}
	type rawUnion struct {
		Kind GitHubTokenAcquireResultKind `json:"kind"`
	}
	var raw rawUnion
	if err := json.Unmarshal(data, &raw); err != nil {
		return nil, err
	}

	switch raw.Kind {
	case GitHubTokenAcquireResultKindCancelled:
		var d GitHubTokenAcquireResultCancelled
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case GitHubTokenAcquireResultKindToken:
		var d GitHubTokenAcquireResultToken
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	default:
		return &RawGitHubTokenAcquireResultData{Discriminator: raw.Kind, Raw: data}, nil
	}
}

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

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

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

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 matchesMCPSerializableServerConfigMCPServerConfigHTTP(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 matchesMCPSerializableServerConfigMCPServerConfigStdio(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 unmarshalMCPSerializableServerConfig(data []byte) (MCPSerializableServerConfig, error) {
	if string(data) == "null" {
		return nil, nil
	}
	if matchesMCPSerializableServerConfigMCPServerConfigHTTP(data) {
		var d MCPServerConfigHTTP
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	}
	if matchesMCPSerializableServerConfigMCPServerConfigStdio(data) {
		var d MCPServerConfigStdio
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	}
	return &RawMCPSerializableServerConfigData{Raw: data}, nil
}

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

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

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

func (r *MCPServerConfigHTTP) UnmarshalJSON(data []byte) error {
	type rawMCPServerConfigHTTP struct {
		Auth                 json.RawMessage                    `json:"auth,omitempty"`
		ConfigWarnings       []string                           `json:"configWarnings,omitzero"`
		DeferTools           *MCPServerConfigDeferTools         `json:"deferTools,omitempty"`
		DisableSecretMasking *bool                              `json:"disableSecretMasking,omitempty"`
		DisableToolCache     *bool                              `json:"disableToolCache,omitempty"`
		DisplayName          *string                            `json:"displayName,omitempty"`
		Events               []string                           `json:"events,omitzero"`
		ExcludeTools         []string                           `json:"excludeTools,omitzero"`
		FilterMapping        json.RawMessage                    `json:"filterMapping,omitempty"`
		Headers              map[string]string                  `json:"headers,omitzero"`
		HeadersRefreshTtlMs  *int64                             `json:"headersRefreshTtlMs,omitempty"`
		IsDefaultServer      *bool                              `json:"isDefaultServer,omitempty"`
		Notifications        []string                           `json:"notifications,omitzero"`
		OauthClientID        *string                            `json:"oauthClientId,omitempty"`
		OauthGrantType       *MCPServerConfigHTTPOauthGrantType `json:"oauthGrantType,omitempty"`
		OauthPublicClient    *bool                              `json:"oauthPublicClient,omitempty"`
		Oidc                 json.RawMessage                    `json:"oidc,omitempty"`
		SafeForTelemetry     json.RawMessage                    `json:"safeForTelemetry,omitempty"`
		Source               *MCPServerSource                   `json:"source,omitempty"`
		SourcePath           *string                            `json:"sourcePath,omitempty"`
		SourcePlugin         *string                            `json:"sourcePlugin,omitempty"`
		SourcePluginSpec     *bool                              `json:"sourcePluginSpec,omitempty"`
		SourcePluginVersion  *string                            `json:"sourcePluginVersion,omitempty"`
		Timeout              *int64                             `json:"timeout,omitempty"`
		Tools                []string                           `json:"tools,omitzero"`
		Type                 *MCPServerConfigHTTPType           `json:"type,omitempty"`
		URL                  string                             `json:"url"`
	}
	var raw rawMCPServerConfigHTTP
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	if raw.Auth != nil {
		value, err := unmarshalMCPServerAuthConfig(raw.Auth)
		if err != nil {
			return err
		}
		r.Auth = value
	}
	r.ConfigWarnings = raw.ConfigWarnings
	r.DeferTools = raw.DeferTools
	r.DisableSecretMasking = raw.DisableSecretMasking
	r.DisableToolCache = raw.DisableToolCache
	r.DisplayName = raw.DisplayName
	r.Events = raw.Events
	r.ExcludeTools = raw.ExcludeTools
	if raw.FilterMapping != nil {
		value, err := unmarshalFilterMapping(raw.FilterMapping)
		if err != nil {
			return err
		}
		r.FilterMapping = value
	}
	r.Headers = raw.Headers
	r.HeadersRefreshTtlMs = raw.HeadersRefreshTtlMs
	r.IsDefaultServer = raw.IsDefaultServer
	r.Notifications = raw.Notifications
	r.OauthClientID = raw.OauthClientID
	r.OauthGrantType = raw.OauthGrantType
	r.OauthPublicClient = raw.OauthPublicClient
	if raw.Oidc != nil {
		value, err := unmarshalMCPServerAuthConfig(raw.Oidc)
		if err != nil {
			return err
		}
		r.Oidc = value
	}
	if raw.SafeForTelemetry != nil {
		value, err := unmarshalMCPSafeForTelemetry(raw.SafeForTelemetry)
		if err != nil {
			return err
		}
		r.SafeForTelemetry = value
	}
	r.Source = raw.Source
	r.SourcePath = raw.SourcePath
	r.SourcePlugin = raw.SourcePlugin
	r.SourcePluginSpec = raw.SourcePluginSpec
	r.SourcePluginVersion = raw.SourcePluginVersion
	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,omitzero"`
		Auth                 json.RawMessage            `json:"auth,omitempty"`
		Command              string                     `json:"command"`
		ConfigWarnings       []string                   `json:"configWarnings,omitzero"`
		Cwd                  *string                    `json:"cwd,omitempty"`
		DeferTools           *MCPServerConfigDeferTools `json:"deferTools,omitempty"`
		DisableSecretMasking *bool                      `json:"disableSecretMasking,omitempty"`
		DisableToolCache     *bool                      `json:"disableToolCache,omitempty"`
		DisplayName          *string                    `json:"displayName,omitempty"`
		Env                  map[string]string          `json:"env,omitzero"`
		Events               []string                   `json:"events,omitzero"`
		ExcludeTools         []string                   `json:"excludeTools,omitzero"`
		FilterMapping        json.RawMessage            `json:"filterMapping,omitempty"`
		IsDefaultServer      *bool                      `json:"isDefaultServer,omitempty"`
		Notifications        []string                   `json:"notifications,omitzero"`
		Oidc                 json.RawMessage            `json:"oidc,omitempty"`
		SafeForTelemetry     json.RawMessage            `json:"safeForTelemetry,omitempty"`
		Source               *MCPServerSource           `json:"source,omitempty"`
		SourcePath           *string                    `json:"sourcePath,omitempty"`
		SourcePlugin         *string                    `json:"sourcePlugin,omitempty"`
		SourcePluginSpec     *bool                      `json:"sourcePluginSpec,omitempty"`
		SourcePluginVersion  *string                    `json:"sourcePluginVersion,omitempty"`
		Timeout              *int64                     `json:"timeout,omitempty"`
		Tools                []string                   `json:"tools,omitzero"`
		Type                 *MCPServerConfigStdioType  `json:"type,omitempty"`
	}
	var raw rawMCPServerConfigStdio
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	r.Args = raw.Args
	if raw.Auth != nil {
		value, err := unmarshalMCPServerAuthConfig(raw.Auth)
		if err != nil {
			return err
		}
		r.Auth = value
	}
	r.Command = raw.Command
	r.ConfigWarnings = raw.ConfigWarnings
	r.Cwd = raw.Cwd
	r.DeferTools = raw.DeferTools
	r.DisableSecretMasking = raw.DisableSecretMasking
	r.DisableToolCache = raw.DisableToolCache
	r.DisplayName = raw.DisplayName
	r.Env = raw.Env
	r.Events = raw.Events
	r.ExcludeTools = raw.ExcludeTools
	if raw.FilterMapping != nil {
		value, err := unmarshalFilterMapping(raw.FilterMapping)
		if err != nil {
			return err
		}
		r.FilterMapping = value
	}
	r.IsDefaultServer = raw.IsDefaultServer
	r.Notifications = raw.Notifications
	if raw.Oidc != nil {
		value, err := unmarshalMCPServerAuthConfig(raw.Oidc)
		if err != nil {
			return err
		}
		r.Oidc = value
	}
	if raw.SafeForTelemetry != nil {
		value, err := unmarshalMCPSafeForTelemetry(raw.SafeForTelemetry)
		if err != nil {
			return err
		}
		r.SafeForTelemetry = value
	}
	r.Source = raw.Source
	r.SourcePath = raw.SourcePath
	r.SourcePlugin = raw.SourcePlugin
	r.SourcePluginSpec = raw.SourcePluginSpec
	r.SourcePluginVersion = raw.SourcePluginVersion
	r.Timeout = raw.Timeout
	r.Tools = raw.Tools
	r.Type = raw.Type
	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 := unmarshalMCPSerializableServerConfig(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]MCPSerializableServerConfig, len(raw.Servers))
		for key, rawValue := range raw.Servers {
			value, err := unmarshalMCPSerializableServerConfig(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 := unmarshalMCPSerializableServerConfig(raw.Config)
		if err != nil {
			return err
		}
		r.Config = value
	}
	r.Name = raw.Name
	return nil
}

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

	switch raw.Kind {
	case MCPHeadersHandlePendingHeadersRefreshRequestKindHeaders:
		var d MCPHeadersHandlePendingHeadersRefreshRequestHeaders
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case MCPHeadersHandlePendingHeadersRefreshRequestKindNone:
		var d MCPHeadersHandlePendingHeadersRefreshRequestNone
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	default:
		return &RawMCPHeadersHandlePendingHeadersRefreshRequestData{Discriminator: raw.Kind, Raw: data}, nil
	}
}

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

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

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

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

func unmarshalMCPPlanTransportChoice(data []byte) (MCPPlanTransportChoice, error) {
	if string(data) == "null" {
		return nil, nil
	}
	type rawUnion struct {
		Transport MCPPlanTransportChoiceTransport `json:"transport"`
	}
	var raw rawUnion
	if err := json.Unmarshal(data, &raw); err != nil {
		return nil, err
	}

	switch raw.Transport {
	case MCPPlanTransportChoiceTransportHTTP:
		var d MCPPlanTransportChoiceRemote
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case MCPPlanTransportChoiceTransportSSE:
		var d MCPPlanTransportChoiceRemote
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case MCPPlanTransportChoiceTransportStdio:
		var d MCPPlanTransportChoicePackage
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case MCPPlanTransportChoiceTransportStreamableHTTP:
		var d MCPPlanTransportChoiceRemote
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	default:
		return &RawMCPPlanTransportChoiceData{Discriminator: raw.Transport, Raw: data}, nil
	}
}

func (r RawMCPPlanTransportChoiceData) MarshalJSON() ([]byte, error) {
	if r.Raw != nil {
		return r.Raw, nil
	}
	return json.Marshal(struct {
		Transport MCPPlanTransportChoiceTransport `json:"transport"`
	}{
		Transport: r.Discriminator,
	})
}

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

	switch raw.Kind {
	case MCPPlanRequiredValueKindEnum:
		var d MCPPlanRequiredValueEnum
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case MCPPlanRequiredValueKindScalar:
		var d MCPPlanRequiredValueScalar
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	default:
		return &RawMCPPlanRequiredValueData{Discriminator: raw.Kind, Raw: data}, nil
	}
}

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

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

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

func (r *MCPPlanTransportChoicePackage) UnmarshalJSON(data []byte) error {
	type rawMCPPlanTransportChoicePackage struct {
		ChoiceID           string                      `json:"choiceId"`
		InstallMethod      MCPPlanPackageInstallMethod `json:"installMethod"`
		PackageIdentifier  string                      `json:"packageIdentifier"`
		PackageType        string                      `json:"packageType"`
		RequiredValues     []json.RawMessage           `json:"requiredValues"`
		SecretPlaceholders []MCPPlanSecretPlaceholder  `json:"secretPlaceholders"`
	}
	var raw rawMCPPlanTransportChoicePackage
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	r.ChoiceID = raw.ChoiceID
	r.InstallMethod = raw.InstallMethod
	r.PackageIdentifier = raw.PackageIdentifier
	r.PackageType = raw.PackageType
	if raw.RequiredValues != nil {
		r.RequiredValues = make([]MCPPlanRequiredValue, 0, len(raw.RequiredValues))
		for _, rawItem := range raw.RequiredValues {
			value, err := unmarshalMCPPlanRequiredValue(rawItem)
			if err != nil {
				return err
			}
			r.RequiredValues = append(r.RequiredValues, value)
		}
	}
	r.SecretPlaceholders = raw.SecretPlaceholders
	return nil
}

func (r MCPPlanTransportChoicePackage) MarshalJSON() ([]byte, error) {
	type alias MCPPlanTransportChoicePackage
	return json.Marshal(struct {
		Transport MCPPlanTransportChoiceTransport `json:"transport"`
		alias
	}{
		Transport: r.Transport(),
		alias:     alias(r),
	})
}

func (r *MCPPlanTransportChoiceRemote) UnmarshalJSON(data []byte) error {
	type rawMCPPlanTransportChoiceRemote struct {
		ChoiceID           string                     `json:"choiceId"`
		Endpoint           string                     `json:"endpoint"`
		InstallMethod      MCPPlanRemoteInstallMethod `json:"installMethod"`
		RequiredValues     []json.RawMessage          `json:"requiredValues"`
		SecretPlaceholders []MCPPlanSecretPlaceholder `json:"secretPlaceholders"`
		Discriminator      MCPPlanRemoteTransport     `json:"transport,omitempty"`
	}
	var raw rawMCPPlanTransportChoiceRemote
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	r.ChoiceID = raw.ChoiceID
	r.Endpoint = raw.Endpoint
	r.InstallMethod = raw.InstallMethod
	if raw.RequiredValues != nil {
		r.RequiredValues = make([]MCPPlanRequiredValue, 0, len(raw.RequiredValues))
		for _, rawItem := range raw.RequiredValues {
			value, err := unmarshalMCPPlanRequiredValue(rawItem)
			if err != nil {
				return err
			}
			r.RequiredValues = append(r.RequiredValues, value)
		}
	}
	r.SecretPlaceholders = raw.SecretPlaceholders
	r.Discriminator = raw.Discriminator
	return nil
}

func (r MCPPlanTransportChoiceRemote) MarshalJSON() ([]byte, error) {
	type alias MCPPlanTransportChoiceRemote
	return json.Marshal(struct {
		Transport MCPPlanTransportChoiceTransport `json:"transport"`
		alias
	}{
		Transport: r.Transport(),
		alias:     alias(r),
	})
}

func (r *MCPInstallPlan) UnmarshalJSON(data []byte) error {
	type rawMCPInstallPlan struct {
		ConfigurationChanges             []MCPPlanConfigurationChange `json:"configurationChanges"`
		Identity                         MCPPlanResourceIdentity      `json:"identity"`
		PlanHandle                       string                       `json:"planHandle"`
		PlanHandleExpiresAt              string                       `json:"planHandleExpiresAt"`
		Policy                           MCPPlanPolicyResult          `json:"policy"`
		Provenance                       MCPPlanProvenance            `json:"provenance"`
		RecommendedTransportChoiceID     *string                      `json:"recommendedTransportChoiceId,omitempty"`
		ReloadRequired                   bool                         `json:"reloadRequired"`
		RequiresInteractiveConfiguration bool                         `json:"requiresInteractiveConfiguration"`
		Target                           MCPPlanTarget                `json:"target"`
		TransportChoices                 []json.RawMessage            `json:"transportChoices"`
	}
	var raw rawMCPInstallPlan
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	r.ConfigurationChanges = raw.ConfigurationChanges
	r.Identity = raw.Identity
	r.PlanHandle = raw.PlanHandle
	r.PlanHandleExpiresAt = raw.PlanHandleExpiresAt
	r.Policy = raw.Policy
	r.Provenance = raw.Provenance
	r.RecommendedTransportChoiceID = raw.RecommendedTransportChoiceID
	r.ReloadRequired = raw.ReloadRequired
	r.RequiresInteractiveConfiguration = raw.RequiresInteractiveConfiguration
	r.Target = raw.Target
	if raw.TransportChoices != nil {
		r.TransportChoices = make([]MCPPlanTransportChoice, 0, len(raw.TransportChoices))
		for _, rawItem := range raw.TransportChoices {
			value, err := unmarshalMCPPlanTransportChoice(rawItem)
			if err != nil {
				return err
			}
			r.TransportChoices = append(r.TransportChoices, value)
		}
	}
	return nil
}

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

	switch raw.Kind {
	case MCPOauthPendingRequestResponseKindCancelled:
		var d MCPOauthPendingRequestResponseCancelled
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case MCPOauthPendingRequestResponseKindToken:
		var d MCPOauthPendingRequestResponseToken
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	default:
		return &RawMCPOauthPendingRequestResponseData{Discriminator: raw.Kind, Raw: data}, nil
	}
}

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

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

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

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

func unmarshalMCPOauthProbeResult(data []byte) (MCPOauthProbeResult, error) {
	if string(data) == "null" {
		return nil, nil
	}
	type rawUnion struct {
		Status MCPOauthProbeResultStatus `json:"status"`
	}
	var raw rawUnion
	if err := json.Unmarshal(data, &raw); err != nil {
		return nil, err
	}

	switch raw.Status {
	case MCPOauthProbeResultStatusAuthenticated:
		var d MCPOauthProbeResultAuthenticated
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case MCPOauthProbeResultStatusFailed:
		var d MCPOauthProbeResultFailed
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case MCPOauthProbeResultStatusNeedsAuth:
		var d MCPOauthProbeResultNeedsAuth
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case MCPOauthProbeResultStatusNoAuthRequired:
		var d MCPOauthProbeResultNoAuthRequired
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	default:
		return &RawMCPOauthProbeResultData{Discriminator: raw.Status, Raw: data}, nil
	}
}

func (r RawMCPOauthProbeResultData) MarshalJSON() ([]byte, error) {
	if r.Raw != nil {
		return r.Raw, nil
	}
	return json.Marshal(struct {
		Status MCPOauthProbeResultStatus `json:"status"`
	}{
		Status: r.Discriminator,
	})
}

func (r MCPOauthProbeResultAuthenticated) MarshalJSON() ([]byte, error) {
	type alias MCPOauthProbeResultAuthenticated
	return json.Marshal(struct {
		Status MCPOauthProbeResultStatus `json:"status"`
		alias
	}{
		Status: r.Status(),
		alias:  alias(r),
	})
}

func (r MCPOauthProbeResultFailed) MarshalJSON() ([]byte, error) {
	type alias MCPOauthProbeResultFailed
	return json.Marshal(struct {
		Status MCPOauthProbeResultStatus `json:"status"`
		alias
	}{
		Status: r.Status(),
		alias:  alias(r),
	})
}

func (r MCPOauthProbeResultNeedsAuth) MarshalJSON() ([]byte, error) {
	type alias MCPOauthProbeResultNeedsAuth
	return json.Marshal(struct {
		Status MCPOauthProbeResultStatus `json:"status"`
		alias
	}{
		Status: r.Status(),
		alias:  alias(r),
	})
}

func (r MCPOauthProbeResultNoAuthRequired) MarshalJSON() ([]byte, error) {
	type alias MCPOauthProbeResultNoAuthRequired
	return json.Marshal(struct {
		Status MCPOauthProbeResultStatus `json:"status"`
		alias
	}{
		Status: r.Status(),
		alias:  alias(r),
	})
}

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

	switch raw.Kind {
	case MCPPlanInstallSourceKindCandidate:
		var d MCPPlanInstallSourceCandidate
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case MCPPlanInstallSourceKindCard:
		var d MCPPlanInstallSourceCard
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	default:
		return &RawMCPPlanInstallSourceData{Discriminator: raw.Kind, Raw: data}, nil
	}
}

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

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

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

	switch raw.Kind {
	case MCPServerCardReferenceKindEmbedded:
		var d MCPServerCardEmbedded
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case MCPServerCardReferenceKindURL:
		var d MCPServerCardURL
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	default:
		return &RawMCPServerCardReferenceData{Discriminator: raw.Kind, Raw: data}, nil
	}
}

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

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

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

func (r *MCPPlanInstallSourceCard) UnmarshalJSON(data []byte) error {
	type rawMCPPlanInstallSourceCard struct {
		Card json.RawMessage `json:"card"`
	}
	var raw rawMCPPlanInstallSourceCard
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	if raw.Card != nil {
		value, err := unmarshalMCPServerCardReference(raw.Card)
		if err != nil {
			return err
		}
		r.Card = value
	}
	return nil
}

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

func (r *MCPPlanInstallRequest) UnmarshalJSON(data []byte) error {
	type rawMCPPlanInstallRequest struct {
		Contract CatalogClientContract `json:"contract"`
		Scope    *MCPPlanScope         `json:"scope,omitempty"`
		Source   json.RawMessage       `json:"source"`
	}
	var raw rawMCPPlanInstallRequest
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	r.Contract = raw.Contract
	r.Scope = raw.Scope
	if raw.Source != nil {
		value, err := unmarshalMCPPlanInstallSource(raw.Source)
		if err != nil {
			return err
		}
		r.Source = value
	}
	return nil
}

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

	switch raw.Kind {
	case MCPPlanInstallResultKindAuthenticationRequired:
		var d CatalogAuthenticationRequiredError
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case MCPPlanInstallResultKindContractViolation:
		var d CatalogContractViolationError
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case MCPPlanInstallResultKindHandleRejected:
		var d CatalogHandleRejectedError
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case MCPPlanInstallResultKindInvalidRequest:
		var d CatalogInvalidRequestError
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case MCPPlanInstallResultKindMalformedCard:
		var d CatalogMalformedCardError
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case MCPPlanInstallResultKindNegotiationRefused:
		var d CatalogNegotiationRefusedError
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case MCPPlanInstallResultKindNetworkFailure:
		var d CatalogNetworkFailureError
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case MCPPlanInstallResultKindNotInstallable:
		var d CatalogNotInstallableError
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case MCPPlanInstallResultKindPlanned:
		var d MCPPlanInstallPlanned
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case MCPPlanInstallResultKindPolicyRejected:
		var d CatalogPolicyRejectedError
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case MCPPlanInstallResultKindUnavailable:
		var d CatalogUnavailableError
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case MCPPlanInstallResultKindUnavailableTransport:
		var d CatalogUnavailableTransportError
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case MCPPlanInstallResultKindUnsafeRetrieval:
		var d CatalogUnsafeRetrievalError
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	default:
		return &RawMCPPlanInstallResultData{Discriminator: raw.Kind, Raw: data}, nil
	}
}

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

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

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

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

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

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

func matchesMCPServerConfigMemory(data []byte) bool {
	var rawGroup0 struct {
		Command        json.RawMessage `json:"command"`
		ServerInstance json.RawMessage `json:"serverInstance"`
		Type           json.RawMessage `json:"type"`
		URL            json.RawMessage `json:"url"`
	}
	if err := json.Unmarshal(data, &rawGroup0); err != nil {
		return false
	}
	if rawGroup0.ServerInstance == nil {
		return false
	}
	if rawGroup0.Type == nil {
		return false
	}
	var rawGroup0String string
	if err := json.Unmarshal(rawGroup0.Type, &rawGroup0String); err != nil {
		return false
	}
	switch rawGroup0String {
	case "memory":
	default:
		return false
	}
	if rawGroup0.Command != nil {
		return false
	}
	return rawGroup0.URL == nil
}

func matchesMCPServerConfigStdio(data []byte) bool {
	var rawGroup0 struct {
		Command        json.RawMessage `json:"command"`
		ServerInstance json.RawMessage `json:"serverInstance"`
		Type           json.RawMessage `json:"type"`
		URL            json.RawMessage `json:"url"`
	}
	if err := json.Unmarshal(data, &rawGroup0); err != nil {
		return false
	}
	if rawGroup0.Command == nil {
		return false
	}
	if rawGroup0.ServerInstance != nil {
		return false
	}
	if rawGroup0.Type != 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 matchesMCPServerConfigMemory(data) {
		var d MCPServerConfigMemory
		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 *MCPServerConfigMemory) UnmarshalJSON(data []byte) error {
	type rawMCPServerConfigMemory struct {
		ConfigWarnings       []string                   `json:"configWarnings,omitzero"`
		DeferTools           *MCPServerConfigDeferTools `json:"deferTools,omitempty"`
		DisableSecretMasking *bool                      `json:"disableSecretMasking,omitempty"`
		DisableToolCache     *bool                      `json:"disableToolCache,omitempty"`
		DisplayName          *string                    `json:"displayName,omitempty"`
		Events               []string                   `json:"events,omitzero"`
		ExcludeTools         []string                   `json:"excludeTools,omitzero"`
		FilterMapping        json.RawMessage            `json:"filterMapping,omitempty"`
		IsDefaultServer      *bool                      `json:"isDefaultServer,omitempty"`
		Notifications        []string                   `json:"notifications,omitzero"`
		Oidc                 json.RawMessage            `json:"oidc,omitempty"`
		SafeForTelemetry     json.RawMessage            `json:"safeForTelemetry,omitempty"`
		ServerInstance       any                        `json:"serverInstance"`
		Source               *MCPServerSource           `json:"source,omitempty"`
		SourcePath           *string                    `json:"sourcePath,omitempty"`
		SourcePlugin         *string                    `json:"sourcePlugin,omitempty"`
		SourcePluginSpec     *bool                      `json:"sourcePluginSpec,omitempty"`
		SourcePluginVersion  *string                    `json:"sourcePluginVersion,omitempty"`
		Timeout              *int64                     `json:"timeout,omitempty"`
		Tools                []string                   `json:"tools,omitzero"`
		Type                 MCPServerConfigMemoryType  `json:"type"`
	}
	var raw rawMCPServerConfigMemory
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	r.ConfigWarnings = raw.ConfigWarnings
	r.DeferTools = raw.DeferTools
	r.DisableSecretMasking = raw.DisableSecretMasking
	r.DisableToolCache = raw.DisableToolCache
	r.DisplayName = raw.DisplayName
	r.Events = raw.Events
	r.ExcludeTools = raw.ExcludeTools
	if raw.FilterMapping != nil {
		value, err := unmarshalFilterMapping(raw.FilterMapping)
		if err != nil {
			return err
		}
		r.FilterMapping = value
	}
	r.IsDefaultServer = raw.IsDefaultServer
	r.Notifications = raw.Notifications
	if raw.Oidc != nil {
		value, err := unmarshalMCPServerAuthConfig(raw.Oidc)
		if err != nil {
			return err
		}
		r.Oidc = value
	}
	if raw.SafeForTelemetry != nil {
		value, err := unmarshalMCPSafeForTelemetry(raw.SafeForTelemetry)
		if err != nil {
			return err
		}
		r.SafeForTelemetry = value
	}
	r.ServerInstance = raw.ServerInstance
	r.Source = raw.Source
	r.SourcePath = raw.SourcePath
	r.SourcePlugin = raw.SourcePlugin
	r.SourcePluginSpec = raw.SourcePluginSpec
	r.SourcePluginVersion = raw.SourcePluginVersion
	r.Timeout = raw.Timeout
	r.Tools = raw.Tools
	r.Type = raw.Type
	return nil
}

func (r *MCPReloadConfig) UnmarshalJSON(data []byte) error {
	type rawMCPReloadConfig struct {
		ActiveGitHubToken       *string                    `json:"activeGitHubToken,omitempty"`
		CLIEnabledServers       []string                   `json:"cliEnabledServers,omitzero"`
		ConfigFilter            any                        `json:"configFilter,omitempty"`
		DisabledServers         []string                   `json:"disabledServers,omitzero"`
		EnabledServers          []string                   `json:"enabledServers,omitzero"`
		ForceRestart            *bool                      `json:"forceRestart,omitempty"`
		GitHubMCPToolOptions    any                        `json:"githubMcpToolOptions,omitempty"`
		GitHubMCPUserOverride   *bool                      `json:"githubMcpUserOverride,omitempty"`
		IncludeWorkspaceSources *bool                      `json:"includeWorkspaceSources,omitempty"`
		Mcp3pEnabled            *bool                      `json:"mcp3pEnabled,omitempty"`
		MCPServers              map[string]json.RawMessage `json:"mcpServers"`
		SecretStore             any                        `json:"secretStore,omitempty"`
		UseCachedToolSnapshots  *bool                      `json:"useCachedToolSnapshots,omitempty"`
	}
	var raw rawMCPReloadConfig
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	r.ActiveGitHubToken = raw.ActiveGitHubToken
	r.CLIEnabledServers = raw.CLIEnabledServers
	r.ConfigFilter = raw.ConfigFilter
	r.DisabledServers = raw.DisabledServers
	r.EnabledServers = raw.EnabledServers
	r.ForceRestart = raw.ForceRestart
	r.GitHubMCPToolOptions = raw.GitHubMCPToolOptions
	r.GitHubMCPUserOverride = raw.GitHubMCPUserOverride
	r.IncludeWorkspaceSources = raw.IncludeWorkspaceSources
	r.Mcp3pEnabled = raw.Mcp3pEnabled
	if raw.MCPServers != nil {
		r.MCPServers = make(map[string]MCPServerConfig, len(raw.MCPServers))
		for key, rawValue := range raw.MCPServers {
			value, err := unmarshalMCPServerConfig(rawValue)
			if err != nil {
				return err
			}
			r.MCPServers[key] = value
		}
	}
	r.SecretStore = raw.SecretStore
	r.UseCachedToolSnapshots = raw.UseCachedToolSnapshots
	return nil
}

func (r *MCPRestartServerRequest) UnmarshalJSON(data []byte) error {
	type rawMCPRestartServerRequest struct {
		Config     json.RawMessage `json:"config,omitempty"`
		ServerName string          `json:"serverName"`
	}
	var raw rawMCPRestartServerRequest
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	if raw.Config != nil {
		value, err := unmarshalMCPSerializableServerConfig(raw.Config)
		if err != nil {
			return err
		}
		r.Config = value
	}
	r.ServerName = raw.ServerName
	return nil
}

func (r *MCPStartServerRequest) UnmarshalJSON(data []byte) error {
	type rawMCPStartServerRequest struct {
		Config     json.RawMessage `json:"config,omitempty"`
		ServerName string          `json:"serverName"`
	}
	var raw rawMCPStartServerRequest
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	if raw.Config != nil {
		value, err := unmarshalMCPSerializableServerConfig(raw.Config)
		if err != nil {
			return err
		}
		r.Config = value
	}
	r.ServerName = raw.ServerName
	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 UserToolSessionApprovalKindExtensionEnvAccess:
		var d UserToolSessionApprovalExtensionEnvAccess
		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 UserToolSessionApprovalKindFactory:
		var d UserToolSessionApprovalFactory
		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 UserToolSessionApprovalExtensionEnvAccess) MarshalJSON() ([]byte, error) {
	type alias UserToolSessionApprovalExtensionEnvAccess
	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 UserToolSessionApprovalFactory) MarshalJSON() ([]byte, error) {
	type alias UserToolSessionApprovalFactory
	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 PermissionDecisionApproveForLocationApprovalKindExtensionEnvAccess:
		var d PermissionDecisionApproveForLocationApprovalExtensionEnvAccess
		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 PermissionDecisionApproveForLocationApprovalKindFactory:
		var d PermissionDecisionApproveForLocationApprovalFactory
		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 PermissionDecisionApproveForLocationApprovalExtensionEnvAccess) MarshalJSON() ([]byte, error) {
	type alias PermissionDecisionApproveForLocationApprovalExtensionEnvAccess
	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 PermissionDecisionApproveForLocationApprovalFactory) MarshalJSON() ([]byte, error) {
	type alias PermissionDecisionApproveForLocationApprovalFactory
	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 PermissionDecisionApproveForSessionApprovalKindExtensionEnvAccess:
		var d PermissionDecisionApproveForSessionApprovalExtensionEnvAccess
		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 PermissionDecisionApproveForSessionApprovalKindFactory:
		var d PermissionDecisionApproveForSessionApprovalFactory
		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 PermissionDecisionApproveForSessionApprovalExtensionEnvAccess) MarshalJSON() ([]byte, error) {
	type alias PermissionDecisionApproveForSessionApprovalExtensionEnvAccess
	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 PermissionDecisionApproveForSessionApprovalFactory) MarshalJSON() ([]byte, error) {
	type alias PermissionDecisionApproveForSessionApprovalFactory
	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 {
		DecisionContext *PermissionDecisionContext `json:"decisionContext,omitempty"`
		RequestID       string                     `json:"requestId"`
		Result          json.RawMessage            `json:"result"`
	}
	var raw rawPermissionDecisionRequest
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	r.DecisionContext = raw.DecisionContext
	r.RequestID = raw.RequestID
	if raw.Result != nil {
		value, err := unmarshalPermissionDecision(raw.Result)
		if err != nil {
			return err
		}
		r.Result = value
	}
	return nil
}

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

	switch raw.Kind {
	case PermissionsLocationsAddToolApprovalDetailsKindCommands:
		var d PermissionsLocationsAddToolApprovalDetailsCommands
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionsLocationsAddToolApprovalDetailsKindCustomTool:
		var d PermissionsLocationsAddToolApprovalDetailsCustomTool
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionsLocationsAddToolApprovalDetailsKindExtensionEnvAccess:
		var d PermissionsLocationsAddToolApprovalDetailsExtensionEnvAccess
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionsLocationsAddToolApprovalDetailsKindExtensionManagement:
		var d PermissionsLocationsAddToolApprovalDetailsExtensionManagement
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionsLocationsAddToolApprovalDetailsKindExtensionPermissionAccess:
		var d PermissionsLocationsAddToolApprovalDetailsExtensionPermissionAccess
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionsLocationsAddToolApprovalDetailsKindFactory:
		var d PermissionsLocationsAddToolApprovalDetailsFactory
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionsLocationsAddToolApprovalDetailsKindMCP:
		var d PermissionsLocationsAddToolApprovalDetailsMCP
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionsLocationsAddToolApprovalDetailsKindMCPSampling:
		var d PermissionsLocationsAddToolApprovalDetailsMCPSampling
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionsLocationsAddToolApprovalDetailsKindMemory:
		var d PermissionsLocationsAddToolApprovalDetailsMemory
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionsLocationsAddToolApprovalDetailsKindRead:
		var d PermissionsLocationsAddToolApprovalDetailsRead
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionsLocationsAddToolApprovalDetailsKindWrite:
		var d PermissionsLocationsAddToolApprovalDetailsWrite
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	default:
		return &RawPermissionsLocationsAddToolApprovalDetailsData{Discriminator: raw.Kind, Raw: data}, nil
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	switch raw.Type {
	case PushAttachmentTypeBlob:
		var d PushAttachmentBlob
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PushAttachmentTypeDirectory:
		var d PushAttachmentDirectory
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PushAttachmentTypeExtensionContext:
		var d ExtensionContextPushInput
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PushAttachmentTypeFile:
		var d PushAttachmentFile
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PushAttachmentTypeGitHubActionsJob:
		var d PushAttachmentGitHubActionsJob
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PushAttachmentTypeGitHubCommit:
		var d PushAttachmentGitHubCommit
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PushAttachmentTypeGitHubFile:
		var d PushAttachmentGitHubFile
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PushAttachmentTypeGitHubFileDiff:
		var d PushAttachmentGitHubFileDiff
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PushAttachmentTypeGitHubReference:
		var d PushAttachmentGitHubReference
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PushAttachmentTypeGitHubRelease:
		var d PushAttachmentGitHubRelease
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PushAttachmentTypeGitHubRepository:
		var d PushAttachmentGitHubRepository
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PushAttachmentTypeGitHubSnippet:
		var d PushAttachmentGitHubSnippet
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PushAttachmentTypeGitHubTreeComparison:
		var d PushAttachmentGitHubTreeComparison
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PushAttachmentTypeGitHubURL:
		var d PushAttachmentGitHubURL
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PushAttachmentTypeSelection:
		var d PushAttachmentSelection
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	default:
		return &RawPushAttachmentData{Discriminator: raw.Type, Raw: data}, nil
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (r *QueueInsertMessage) UnmarshalJSON(data []byte) error {
	type rawQueueInsertMessage struct {
		AgentMode      *SendAgentMode    `json:"agentMode,omitempty"`
		Attachments    []json.RawMessage `json:"attachments,omitzero"`
		Billable       *bool             `json:"billable,omitempty"`
		Delivery       *string           `json:"delivery,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,omitzero"`
		RequiredTool   *string           `json:"requiredTool,omitempty"`
		Source         *string           `json:"source,omitempty"`
		Wait           *bool             `json:"wait,omitempty"`
	}
	var raw rawQueueInsertMessage
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	r.AgentMode = raw.AgentMode
	if raw.Attachments != nil {
		r.Attachments = make([]Attachment, 0, len(raw.Attachments))
		for _, rawItem := range raw.Attachments {
			value, err := unmarshalAttachment(rawItem)
			if err != nil {
				return err
			}
			r.Attachments = append(r.Attachments, value)
		}
	}
	r.Billable = raw.Billable
	r.Delivery = raw.Delivery
	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.Wait = raw.Wait
	return nil
}

func unmarshalRemoteControlStatus(data []byte) (RemoteControlStatus, error) {
	if string(data) == "null" {
		return nil, nil
	}
	type rawUnion struct {
		State RemoteControlStatusState `json:"state"`
	}
	var raw rawUnion
	if err := json.Unmarshal(data, &raw); err != nil {
		return nil, err
	}

	switch raw.State {
	case RemoteControlStatusStateActive:
		var d RemoteControlStatusActive
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case RemoteControlStatusStateConnecting:
		var d RemoteControlStatusConnecting
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case RemoteControlStatusStateError:
		var d RemoteControlStatusError
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case RemoteControlStatusStateOff:
		var d RemoteControlStatusOff
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	default:
		return &RawRemoteControlStatusData{Discriminator: raw.State, Raw: data}, nil
	}
}

func (r RawRemoteControlStatusData) MarshalJSON() ([]byte, error) {
	if r.Raw != nil {
		return r.Raw, nil
	}
	return json.Marshal(struct {
		State RemoteControlStatusState `json:"state"`
	}{
		State: r.Discriminator,
	})
}

func (r RemoteControlStatusActive) MarshalJSON() ([]byte, error) {
	type alias RemoteControlStatusActive
	return json.Marshal(struct {
		State RemoteControlStatusState `json:"state"`
		alias
	}{
		State: r.State(),
		alias: alias(r),
	})
}

func (r RemoteControlStatusConnecting) MarshalJSON() ([]byte, error) {
	type alias RemoteControlStatusConnecting
	return json.Marshal(struct {
		State RemoteControlStatusState `json:"state"`
		alias
	}{
		State: r.State(),
		alias: alias(r),
	})
}

func (r RemoteControlStatusError) MarshalJSON() ([]byte, error) {
	type alias RemoteControlStatusError
	return json.Marshal(struct {
		State RemoteControlStatusState `json:"state"`
		alias
	}{
		State: r.State(),
		alias: alias(r),
	})
}

func (r RemoteControlStatusOff) MarshalJSON() ([]byte, error) {
	type alias RemoteControlStatusOff
	return json.Marshal(struct {
		State RemoteControlStatusState `json:"state"`
		alias
	}{
		State: r.State(),
		alias: alias(r),
	})
}

func (r *RemoteControlStatusResult) UnmarshalJSON(data []byte) error {
	type rawRemoteControlStatusResult struct {
		Status json.RawMessage `json:"status"`
	}
	var raw rawRemoteControlStatusResult
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	if raw.Status != nil {
		value, err := unmarshalRemoteControlStatus(raw.Status)
		if err != nil {
			return err
		}
		r.Status = value
	}
	return nil
}

func (r *RemoteControlStopResult) UnmarshalJSON(data []byte) error {
	type rawRemoteControlStopResult struct {
		Status  json.RawMessage `json:"status"`
		Stopped bool            `json:"stopped"`
	}
	var raw rawRemoteControlStopResult
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	if raw.Status != nil {
		value, err := unmarshalRemoteControlStatus(raw.Status)
		if err != nil {
			return err
		}
		r.Status = value
	}
	r.Stopped = raw.Stopped
	return nil
}

func (r *RemoteControlTransferResult) UnmarshalJSON(data []byte) error {
	type rawRemoteControlTransferResult struct {
		Status      json.RawMessage `json:"status"`
		Transferred bool            `json:"transferred"`
	}
	var raw rawRemoteControlTransferResult
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	if raw.Status != nil {
		value, err := unmarshalRemoteControlStatus(raw.Status)
		if err != nil {
			return err
		}
		r.Status = value
	}
	r.Transferred = raw.Transferred
	return nil
}

func (r *SendAttachmentsToMessageParams) UnmarshalJSON(data []byte) error {
	type rawSendAttachmentsToMessageParams struct {
		Attachments []json.RawMessage `json:"attachments"`
		InstanceID  *string           `json:"instanceId,omitempty"`
	}
	var raw rawSendAttachmentsToMessageParams
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	if raw.Attachments != nil {
		r.Attachments = make([]PushAttachment, 0, len(raw.Attachments))
		for _, rawItem := range raw.Attachments {
			value, err := unmarshalPushAttachment(rawItem)
			if err != nil {
				return err
			}
			r.Attachments = append(r.Attachments, value)
		}
	}
	r.InstanceID = raw.InstanceID
	return nil
}

func (r *SendMessageItem) UnmarshalJSON(data []byte) error {
	type rawSendMessageItem struct {
		Attachments   []json.RawMessage `json:"attachments,omitzero"`
		Billable      *bool             `json:"billable,omitempty"`
		DisplayPrompt *string           `json:"displayPrompt,omitempty"`
		Prompt        string            `json:"prompt"`
		RequiredTool  *string           `json:"requiredTool,omitempty"`
		Source        *string           `json:"source,omitempty"`
	}
	var raw rawSendMessageItem
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	if raw.Attachments != nil {
		r.Attachments = make([]Attachment, 0, len(raw.Attachments))
		for _, rawItem := range raw.Attachments {
			value, err := unmarshalAttachment(rawItem)
			if err != nil {
				return err
			}
			r.Attachments = append(r.Attachments, value)
		}
	}
	r.Billable = raw.Billable
	r.DisplayPrompt = raw.DisplayPrompt
	r.Prompt = raw.Prompt
	r.RequiredTool = raw.RequiredTool
	r.Source = raw.Source
	return nil
}

func (r *SendRequest) UnmarshalJSON(data []byte) error {
	type rawSendRequest struct {
		AgentMode      *SendAgentMode    `json:"agentMode,omitempty"`
		Attachments    []json.RawMessage `json:"attachments,omitzero"`
		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,omitzero"`
		RequiredTool   *string           `json:"requiredTool,omitempty"`
		Source         *string           `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([]Attachment, 0, len(raw.Attachments))
		for _, rawItem := range raw.Attachments {
			value, err := unmarshalAttachment(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 *SessionAuthLogoutUserRequest) UnmarshalJSON(data []byte) error {
	type rawSessionAuthLogoutUserRequest struct {
		AuthInfo json.RawMessage `json:"authInfo"`
	}
	var raw rawSessionAuthLogoutUserRequest
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	if raw.AuthInfo != nil {
		value, err := unmarshalAuthInfo(raw.AuthInfo)
		if err != nil {
			return err
		}
		r.AuthInfo = value
	}
	return nil
}

func (r *SessionAuthSwitchRequest) UnmarshalJSON(data []byte) error {
	type rawSessionAuthSwitchRequest struct {
		AuthInfo json.RawMessage `json:"authInfo"`
		Token    *string         `json:"token,omitempty"`
	}
	var raw rawSessionAuthSwitchRequest
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	if raw.AuthInfo != nil {
		value, err := unmarshalAuthInfo(raw.AuthInfo)
		if err != nil {
			return err
		}
		r.AuthInfo = value
	}
	r.Token = raw.Token
	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 unmarshalSessionLimitPredictionResult(data []byte) (SessionLimitPredictionResult, error) {
	if string(data) == "null" {
		return nil, nil
	}
	type rawUnion struct {
		Kind SessionLimitPredictionResultKind `json:"kind"`
	}
	var raw rawUnion
	if err := json.Unmarshal(data, &raw); err != nil {
		return nil, err
	}

	switch raw.Kind {
	case SessionLimitPredictionResultKindAvailable:
		var d SessionLimitPredictionResultAvailable
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case SessionLimitPredictionResultKindUnavailable:
		var d SessionLimitPredictionResultUnavailable
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	default:
		return &RawSessionLimitPredictionResultData{Discriminator: raw.Kind, Raw: data}, nil
	}
}

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

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

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

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

	switch *raw.IsRemote {
	case false:
		var d LocalSessionMetadataValue
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case true:
		var d RemoteSessionMetadataValue
		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 SessionListEntry")
}

func (r LocalSessionMetadataValue) MarshalJSON() ([]byte, error) {
	type alias LocalSessionMetadataValue
	return json.Marshal(struct {
		IsRemote bool `json:"isRemote"`
		alias
	}{
		IsRemote: r.sessionListEntryIsRemote(),
		alias:    alias(r),
	})
}

func (r RemoteSessionMetadataValue) MarshalJSON() ([]byte, error) {
	type alias RemoteSessionMetadataValue
	return json.Marshal(struct {
		IsRemote bool `json:"isRemote"`
		alias
	}{
		IsRemote: r.sessionListEntryIsRemote(),
		alias:    alias(r),
	})
}

func (r *SessionList) UnmarshalJSON(data []byte) error {
	type rawSessionList struct {
		Sessions []json.RawMessage `json:"sessions"`
	}
	var raw rawSessionList
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	if raw.Sessions != nil {
		r.Sessions = make([]SessionListEntry, 0, len(raw.Sessions))
		for _, rawItem := range raw.Sessions {
			value, err := unmarshalSessionListEntry(rawItem)
			if err != nil {
				return err
			}
			r.Sessions = append(r.Sessions, value)
		}
	}
	return nil
}

func (r *SessionOpenOptions) UnmarshalJSON(data []byte) error {
	type rawSessionOpenOptions struct {
		AdditionalContentExclusionPolicies     []SessionOpenOptionsAdditionalContentExclusionPolicy `json:"additionalContentExclusionPolicies,omitzero"`
		AdditionalDirectories                  []string                                             `json:"additionalDirectories,omitzero"`
		AgentContext                           *string                                              `json:"agentContext,omitempty"`
		AllowAllMCPServerInstructions          *bool                                                `json:"allowAllMcpServerInstructions,omitempty"`
		AskUserDisabled                        *bool                                                `json:"askUserDisabled,omitempty"`
		AuthClientIDMetadataURL                *string                                              `json:"authClientIdMetadataUrl,omitempty"`
		AuthInfo                               json.RawMessage                                      `json:"authInfo,omitempty"`
		AvailableTools                         []string                                             `json:"availableTools,omitzero"`
		Capi                                   *CapiSessionOptions                                  `json:"capi,omitempty"`
		ClientKind                             *string                                              `json:"clientKind,omitempty"`
		ClientName                             *string                                              `json:"clientName,omitempty"`
		CoauthorEnabled                        *bool                                                `json:"coauthorEnabled,omitempty"`
		ConfigDir                              *string                                              `json:"configDir,omitempty"`
		ContinueOnAutoMode                     *bool                                                `json:"continueOnAutoMode,omitempty"`
		CopilotURL                             *string                                              `json:"copilotUrl,omitempty"`
		CustomAgentsLocalOnly                  *bool                                                `json:"customAgentsLocalOnly,omitempty"`
		DetachedFromSpawningParentEngagementID *string                                              `json:"detachedFromSpawningParentEngagementId,omitempty"`
		DetachedFromSpawningParentSessionID    *string                                              `json:"detachedFromSpawningParentSessionId,omitempty"`
		DisabledInstructionSources             []string                                             `json:"disabledInstructionSources,omitzero"`
		DisabledMCPServers                     []string                                             `json:"disabledMcpServers,omitzero"`
		DisabledSkills                         []string                                             `json:"disabledSkills,omitzero"`
		EnableCitations                        *bool                                                `json:"enableCitations,omitempty"`
		EnableFileChangeTracking               *bool                                                `json:"enableFileChangeTracking,omitempty"`
		EnableManagedSettings                  *bool                                                `json:"enableManagedSettings,omitempty"`
		EnableOnDemandInstructionDiscovery     *bool                                                `json:"enableOnDemandInstructionDiscovery,omitempty"`
		EnableScriptSafety                     *bool                                                `json:"enableScriptSafety,omitempty"`
		EnableSkills                           *bool                                                `json:"enableSkills,omitempty"`
		EnableStreaming                        *bool                                                `json:"enableStreaming,omitempty"`
		EnvValueMode                           *SessionOpenOptionsEnvValueMode                      `json:"envValueMode,omitempty"`
		EventsLogDirectory                     *string                                              `json:"eventsLogDirectory,omitempty"`
		EventsLogIncludesSubagents             *bool                                                `json:"eventsLogIncludesSubagents,omitempty"`
		ExcludedBuiltinAgents                  []string                                             `json:"excludedBuiltinAgents,omitzero"`
		ExcludedTools                          []string                                             `json:"excludedTools,omitzero"`
		ExpAssignments                         any                                                  `json:"expAssignments,omitempty"`
		FeatureFlags                           map[string]bool                                      `json:"featureFlags,omitzero"`
		HasSkillProvider                       *bool                                                `json:"hasSkillProvider,omitempty"`
		IncludedBuiltinAgents                  []string                                             `json:"includedBuiltinAgents,omitzero"`
		IncludedBuiltinSkills                  []string                                             `json:"includedBuiltinSkills,omitzero"`
		InstalledPlugins                       []InstalledPlugin                                    `json:"installedPlugins,omitzero"`
		IntegrationID                          *string                                              `json:"integrationId,omitempty"`
		IsExperimentalMode                     *bool                                                `json:"isExperimentalMode,omitempty"`
		LogInteractiveShells                   *bool                                                `json:"logInteractiveShells,omitempty"`
		LspClientName                          *string                                              `json:"lspClientName,omitempty"`
		ManagedSettings                        *SessionManagedSettings                              `json:"managedSettings,omitempty"`
		MaxInlineBinaryBytes                   *int64                                               `json:"maxInlineBinaryBytes,omitempty"`
		Memory                                 *MemoryConfiguration                                 `json:"memory,omitempty"`
		Model                                  *string                                              `json:"model,omitempty"`
		ModelCapabilitiesOverrides             *ModelCapabilitiesOverride                           `json:"modelCapabilitiesOverrides,omitempty"`
		Models                                 []ProviderModelConfig                                `json:"models,omitzero"`
		Name                                   *string                                              `json:"name,omitempty"`
		Provider                               *ProviderConfig                                      `json:"provider,omitempty"`
		Providers                              []NamedProviderConfig                                `json:"providers,omitzero"`
		ReasoningEffort                        *string                                              `json:"reasoningEffort,omitempty"`
		ReasoningSummary                       *SessionOpenOptionsReasoningSummary                  `json:"reasoningSummary,omitempty"`
		RemoteDefaultedOn                      *bool                                                `json:"remoteDefaultedOn,omitempty"`
		RemoteExporting                        *bool                                                `json:"remoteExporting,omitempty"`
		RemoteSteerable                        *bool                                                `json:"remoteSteerable,omitempty"`
		RunningInInteractiveMode               *bool                                                `json:"runningInInteractiveMode,omitempty"`
		SandboxConfig                          *SandboxConfig                                       `json:"sandboxConfig,omitempty"`
		SandboxConfigSource                    *SandboxConfigSource                                 `json:"sandboxConfigSource,omitempty"`
		SessionCapabilities                    []SessionCapability                                  `json:"sessionCapabilities,omitzero"`
		SessionID                              *string                                              `json:"sessionId,omitempty"`
		SessionLimits                          *SessionLimitsConfig                                 `json:"sessionLimits,omitempty"`
		Shell                                  *ShellOptions                                        `json:"shell,omitempty"`
		ShellInitProfile                       *string                                              `json:"shellInitProfile,omitempty"`
		ShellProcessFlags                      []string                                             `json:"shellProcessFlags,omitzero"`
		SkillDirectories                       []string                                             `json:"skillDirectories,omitzero"`
		SkipCustomInstructions                 *bool                                                `json:"skipCustomInstructions,omitempty"`
		TrajectoryFile                         *string                                              `json:"trajectoryFile,omitempty"`
		Verbosity                              *Verbosity                                           `json:"verbosity,omitempty"`
		WorkingDirectory                       *string                                              `json:"workingDirectory,omitempty"`
		WorkingDirectoryContext                *SessionContext                                      `json:"workingDirectoryContext,omitempty"`
	}
	var raw rawSessionOpenOptions
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	r.AdditionalContentExclusionPolicies = raw.AdditionalContentExclusionPolicies
	r.AdditionalDirectories = raw.AdditionalDirectories
	r.AgentContext = raw.AgentContext
	r.AllowAllMCPServerInstructions = raw.AllowAllMCPServerInstructions
	r.AskUserDisabled = raw.AskUserDisabled
	r.AuthClientIDMetadataURL = raw.AuthClientIDMetadataURL
	if raw.AuthInfo != nil {
		value, err := unmarshalAuthInfo(raw.AuthInfo)
		if err != nil {
			return err
		}
		r.AuthInfo = value
	}
	r.AvailableTools = raw.AvailableTools
	r.Capi = raw.Capi
	r.ClientKind = raw.ClientKind
	r.ClientName = raw.ClientName
	r.CoauthorEnabled = raw.CoauthorEnabled
	r.ConfigDir = raw.ConfigDir
	r.ContinueOnAutoMode = raw.ContinueOnAutoMode
	r.CopilotURL = raw.CopilotURL
	r.CustomAgentsLocalOnly = raw.CustomAgentsLocalOnly
	r.DetachedFromSpawningParentEngagementID = raw.DetachedFromSpawningParentEngagementID
	r.DetachedFromSpawningParentSessionID = raw.DetachedFromSpawningParentSessionID
	r.DisabledInstructionSources = raw.DisabledInstructionSources
	r.DisabledMCPServers = raw.DisabledMCPServers
	r.DisabledSkills = raw.DisabledSkills
	r.EnableCitations = raw.EnableCitations
	r.EnableFileChangeTracking = raw.EnableFileChangeTracking
	r.EnableManagedSettings = raw.EnableManagedSettings
	r.EnableOnDemandInstructionDiscovery = raw.EnableOnDemandInstructionDiscovery
	r.EnableScriptSafety = raw.EnableScriptSafety
	r.EnableSkills = raw.EnableSkills
	r.EnableStreaming = raw.EnableStreaming
	r.EnvValueMode = raw.EnvValueMode
	r.EventsLogDirectory = raw.EventsLogDirectory
	r.EventsLogIncludesSubagents = raw.EventsLogIncludesSubagents
	r.ExcludedBuiltinAgents = raw.ExcludedBuiltinAgents
	r.ExcludedTools = raw.ExcludedTools
	r.ExpAssignments = raw.ExpAssignments
	r.FeatureFlags = raw.FeatureFlags
	r.HasSkillProvider = raw.HasSkillProvider
	r.IncludedBuiltinAgents = raw.IncludedBuiltinAgents
	r.IncludedBuiltinSkills = raw.IncludedBuiltinSkills
	r.InstalledPlugins = raw.InstalledPlugins
	r.IntegrationID = raw.IntegrationID
	r.IsExperimentalMode = raw.IsExperimentalMode
	r.LogInteractiveShells = raw.LogInteractiveShells
	r.LspClientName = raw.LspClientName
	r.ManagedSettings = raw.ManagedSettings
	r.MaxInlineBinaryBytes = raw.MaxInlineBinaryBytes
	r.Memory = raw.Memory
	r.Model = raw.Model
	r.ModelCapabilitiesOverrides = raw.ModelCapabilitiesOverrides
	r.Models = raw.Models
	r.Name = raw.Name
	r.Provider = raw.Provider
	r.Providers = raw.Providers
	r.ReasoningEffort = raw.ReasoningEffort
	r.ReasoningSummary = raw.ReasoningSummary
	r.RemoteDefaultedOn = raw.RemoteDefaultedOn
	r.RemoteExporting = raw.RemoteExporting
	r.RemoteSteerable = raw.RemoteSteerable
	r.RunningInInteractiveMode = raw.RunningInInteractiveMode
	r.SandboxConfig = raw.SandboxConfig
	r.SandboxConfigSource = raw.SandboxConfigSource
	r.SessionCapabilities = raw.SessionCapabilities
	r.SessionID = raw.SessionID
	r.SessionLimits = raw.SessionLimits
	r.Shell = raw.Shell
	r.ShellInitProfile = raw.ShellInitProfile
	r.ShellProcessFlags = raw.ShellProcessFlags
	r.SkillDirectories = raw.SkillDirectories
	r.SkipCustomInstructions = raw.SkipCustomInstructions
	r.TrajectoryFile = raw.TrajectoryFile
	r.Verbosity = raw.Verbosity
	r.WorkingDirectory = raw.WorkingDirectory
	r.WorkingDirectoryContext = raw.WorkingDirectoryContext
	return nil
}

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

	switch raw.Kind {
	case SessionOpenParamsKindAttach:
		var d SessionsOpenAttach
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case SessionOpenParamsKindCloud:
		var d SessionsOpenCloud
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case SessionOpenParamsKindCreate:
		var d SessionsOpenCreate
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case SessionOpenParamsKindHandoff:
		var d SessionsOpenHandoff
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case SessionOpenParamsKindRemote:
		var d SessionsOpenRemote
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case SessionOpenParamsKindResume:
		var d SessionsOpenResume
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case SessionOpenParamsKindResumeLast:
		var d SessionsOpenResumeLast
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	default:
		return &RawSessionOpenParamsData{Discriminator: raw.Kind, Raw: data}, nil
	}
}

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

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

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

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

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

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

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

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

func unmarshalSessionsClientMetadataEntry(data []byte) (SessionsClientMetadataEntry, error) {
	if string(data) == "null" {
		return nil, nil
	}
	type rawUnion struct {
		Status SessionsClientMetadataEntryStatus `json:"status"`
	}
	var raw rawUnion
	if err := json.Unmarshal(data, &raw); err != nil {
		return nil, err
	}

	switch raw.Status {
	case SessionsClientMetadataEntryStatusCorrupt:
		var d SessionsClientMetadataEntryCorrupt
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case SessionsClientMetadataEntryStatusNotFound:
		var d SessionsClientMetadataEntryNotFound
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case SessionsClientMetadataEntryStatusOk:
		var d SessionsClientMetadataEntryOk
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case SessionsClientMetadataEntryStatusUnavailable:
		var d SessionsClientMetadataEntryUnavailable
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case SessionsClientMetadataEntryStatusUnsupportedVersion:
		var d SessionsClientMetadataEntryUnsupportedVersion
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	default:
		return &RawSessionsClientMetadataEntryData{Discriminator: raw.Status, Raw: data}, nil
	}
}

func (r RawSessionsClientMetadataEntryData) MarshalJSON() ([]byte, error) {
	if r.Raw != nil {
		return r.Raw, nil
	}
	return json.Marshal(struct {
		Status SessionsClientMetadataEntryStatus `json:"status"`
	}{
		Status: r.Discriminator,
	})
}

func (r SessionsClientMetadataEntryCorrupt) MarshalJSON() ([]byte, error) {
	type alias SessionsClientMetadataEntryCorrupt
	return json.Marshal(struct {
		Status SessionsClientMetadataEntryStatus `json:"status"`
		alias
	}{
		Status: r.Status(),
		alias:  alias(r),
	})
}

func (r SessionsClientMetadataEntryNotFound) MarshalJSON() ([]byte, error) {
	type alias SessionsClientMetadataEntryNotFound
	return json.Marshal(struct {
		Status SessionsClientMetadataEntryStatus `json:"status"`
		alias
	}{
		Status: r.Status(),
		alias:  alias(r),
	})
}

func (r SessionsClientMetadataEntryOk) MarshalJSON() ([]byte, error) {
	type alias SessionsClientMetadataEntryOk
	return json.Marshal(struct {
		Status SessionsClientMetadataEntryStatus `json:"status"`
		alias
	}{
		Status: r.Status(),
		alias:  alias(r),
	})
}

func (r SessionsClientMetadataEntryUnavailable) MarshalJSON() ([]byte, error) {
	type alias SessionsClientMetadataEntryUnavailable
	return json.Marshal(struct {
		Status SessionsClientMetadataEntryStatus `json:"status"`
		alias
	}{
		Status: r.Status(),
		alias:  alias(r),
	})
}

func (r SessionsClientMetadataEntryUnsupportedVersion) MarshalJSON() ([]byte, error) {
	type alias SessionsClientMetadataEntryUnsupportedVersion
	return json.Marshal(struct {
		Status SessionsClientMetadataEntryStatus `json:"status"`
		alias
	}{
		Status: r.Status(),
		alias:  alias(r),
	})
}

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

	switch raw.Type {
	case SettableAuthInfoTypeAPIKey:
		var d APIKeyAuthInfo
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case SettableAuthInfoTypeCopilotAPIToken:
		var d CopilotAPITokenAuthInfo
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case SettableAuthInfoTypeEnv:
		var d EnvAuthInfo
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case SettableAuthInfoTypeGhCLI:
		var d GhCLIAuthInfo
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case SettableAuthInfoTypeHMAC:
		var d HMACAuthInfo
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case SettableAuthInfoTypeToken:
		var d SettableTokenAuthInfo
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case SettableAuthInfoTypeUser:
		var d UserAuthInfo
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	default:
		return &RawSettableAuthInfoData{Discriminator: raw.Type, Raw: data}, nil
	}
}

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

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

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 := unmarshalSettableAuthInfo(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 SlashCommandInvocationResultKindAddTimelineEntry:
		var d SlashCommandAddTimelineEntryResult
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	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 SlashCommandInvocationResultKindSetModel:
		var d SlashCommandSetModelResult
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case SlashCommandInvocationResultKindSetPlanModel:
		var d SlashCommandSetPlanModelResult
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case SlashCommandInvocationResultKindShowDialog:
		var d SlashCommandShowDialogResult
		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 SlashCommandAddTimelineEntryResult) MarshalJSON() ([]byte, error) {
	type alias SlashCommandAddTimelineEntryResult
	return json.Marshal(struct {
		Kind SlashCommandInvocationResultKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		alias: alias(r),
	})
}

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 SlashCommandSetModelResult) MarshalJSON() ([]byte, error) {
	type alias SlashCommandSetModelResult
	return json.Marshal(struct {
		Kind SlashCommandInvocationResultKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		alias: alias(r),
	})
}

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

func (r SlashCommandShowDialogResult) MarshalJSON() ([]byte, error) {
	type alias SlashCommandShowDialogResult
	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 unmarshalTaskClientUpdate(data []byte) (TaskClientUpdate, error) {
	if string(data) == "null" {
		return nil, nil
	}
	type rawUnion struct {
		Kind TaskClientUpdateKind `json:"kind"`
	}
	var raw rawUnion
	if err := json.Unmarshal(data, &raw); err != nil {
		return nil, err
	}

	switch raw.Kind {
	case TaskClientUpdateKindCancelled:
		var d TaskClientUpdateCancelled
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case TaskClientUpdateKindCompleted:
		var d TaskClientUpdateCompleted
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case TaskClientUpdateKindFailed:
		var d TaskClientUpdateFailed
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case TaskClientUpdateKindProgress:
		var d TaskClientUpdateProgress
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	default:
		return &RawTaskClientUpdateData{Discriminator: raw.Kind, Raw: data}, nil
	}
}

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

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

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

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

func (r TaskClientUpdateProgress) MarshalJSON() ([]byte, error) {
	type alias TaskClientUpdateProgress
	return json.Marshal(struct {
		Kind TaskClientUpdateKind `json:"kind"`
		alias
	}{
		Kind:  r.Kind(),
		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 TaskInfoTypeClient:
		var d TaskClientInfo
		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 TaskClientInfo) MarshalJSON() ([]byte, error) {
	type alias TaskClientInfo
	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 unmarshalTaskProgress(data []byte) (TaskProgress, error) {
	if string(data) == "null" {
		return nil, nil
	}
	type rawUnion struct {
		Type TaskProgressType `json:"type"`
	}
	var raw rawUnion
	if err := json.Unmarshal(data, &raw); err != nil {
		return nil, err
	}

	switch raw.Type {
	case TaskProgressTypeAgent:
		var d TaskAgentProgress
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case TaskProgressTypeClient:
		var d TaskClientProgress
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case TaskProgressTypeShell:
		var d TaskShellProgress
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	default:
		return &RawTaskProgressData{Discriminator: raw.Type, Raw: data}, nil
	}
}

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

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

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

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

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 *TasksGetProgressResult) UnmarshalJSON(data []byte) error {
	type rawTasksGetProgressResult struct {
		Progress json.RawMessage `json:"progress,omitempty"`
	}
	var raw rawTasksGetProgressResult
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	if raw.Progress != nil {
		value, err := unmarshalTaskProgress(raw.Progress)
		if err != nil {
			return err
		}
		r.Progress = 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 (r *TasksUpdateRequest) UnmarshalJSON(data []byte) error {
	type rawTasksUpdateRequest struct {
		ID       string          `json:"id"`
		Sequence int64           `json:"sequence"`
		Update   json.RawMessage `json:"update"`
	}
	var raw rawTasksUpdateRequest
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	r.ID = raw.ID
	r.Sequence = raw.Sequence
	if raw.Update != nil {
		value, err := unmarshalTaskClientUpdate(raw.Update)
		if err != nil {
			return err
		}
		r.Update = value
	}
	return nil
}

func (r *ToolResultExpanded) UnmarshalJSON(data []byte) error {
	type rawToolResultExpanded struct {
		BinaryResultsForLlm              []ExternalToolTextResultForLlmBinaryResultsForLlm `json:"binaryResultsForLlm,omitzero"`
		CitableSources                   []any                                             `json:"citableSources,omitzero"`
		Contents                         []json.RawMessage                                 `json:"contents,omitzero"`
		Error                            *string                                           `json:"error,omitempty"`
		MCPMeta                          map[string]any                                    `json:"mcpMeta,omitzero"`
		NewMessages                      []ToolResultNewMessage                            `json:"newMessages,omitzero"`
		PostToolUseFailureHooksProcessed *bool                                             `json:"postToolUseFailureHooksProcessed,omitempty"`
		ResultType                       ToolResultType                                    `json:"resultType"`
		SessionLog                       *string                                           `json:"sessionLog,omitempty"`
		SkillInvocation                  any                                               `json:"skillInvocation,omitempty"`
		SkipLargeOutputProcessing        *bool                                             `json:"skipLargeOutputProcessing,omitempty"`
		StructuredContent                any                                               `json:"structuredContent,omitempty"`
		TaskCompletionDecision           *TaskCompletionDecision                           `json:"taskCompletionDecision,omitempty"`
		TextResultForLlm                 string                                            `json:"textResultForLlm"`
		ToolReferences                   []string                                          `json:"toolReferences,omitzero"`
		ToolTelemetry                    any                                               `json:"toolTelemetry,omitempty"`
		UIResource                       any                                               `json:"uiResource,omitempty"`
	}
	var raw rawToolResultExpanded
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	r.BinaryResultsForLlm = raw.BinaryResultsForLlm
	r.CitableSources = raw.CitableSources
	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.MCPMeta = raw.MCPMeta
	r.NewMessages = raw.NewMessages
	r.PostToolUseFailureHooksProcessed = raw.PostToolUseFailureHooksProcessed
	r.ResultType = raw.ResultType
	r.SessionLog = raw.SessionLog
	r.SkillInvocation = raw.SkillInvocation
	r.SkipLargeOutputProcessing = raw.SkipLargeOutputProcessing
	r.StructuredContent = raw.StructuredContent
	r.TaskCompletionDecision = raw.TaskCompletionDecision
	r.TextResultForLlm = raw.TextResultForLlm
	r.ToolReferences = raw.ToolReferences
	r.ToolTelemetry = raw.ToolTelemetry
	r.UIResource = raw.UIResource
	return nil
}

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

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 matchesUIElicitationSchemaPropertyUIElicitationArrayAnyOfField(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 matchesUIElicitationSchemaPropertyUIElicitationArrayEnumField(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 matchesUIElicitationSchemaPropertyUIElicitationStringEnumField(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 matchesUIElicitationSchemaPropertyUIElicitationStringOneOfField(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 matchesUIElicitationSchemaPropertyUIElicitationArrayAnyOfField(data) {
			var d UIElicitationArrayAnyOfField
			if err := json.Unmarshal(data, &d); err != nil {
				return nil, err
			}
			return &d, nil
		}
		if matchesUIElicitationSchemaPropertyUIElicitationArrayEnumField(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 matchesUIElicitationSchemaPropertyUIElicitationStringEnumField(data) {
			var d UIElicitationStringEnumField
			if err := json.Unmarshal(data, &d); err != nil {
				return nil, err
			}
			return &d, nil
		}
		if matchesUIElicitationSchemaPropertyUIElicitationStringOneOfField(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,omitzero"`
		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,omitzero"`
		Meta    map[string]any              `json:"_meta,omitzero"`
	}
	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
		}
	}
	r.Meta = raw.Meta
	return nil
}