zsession_encoding.go

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

package rpc

import (
	"encoding/json"
	"errors"
	"time"
)

// Marshal serializes the SessionEvent to JSON.
func (r *SessionEvent) Marshal() ([]byte, error) {
	return json.Marshal(r)
}

func (e *SessionEvent) UnmarshalJSON(data []byte) error {
	type rawEvent struct {
		AgentID   *string          `json:"agentId,omitempty"`
		Data      json.RawMessage  `json:"data"`
		Ephemeral *bool            `json:"ephemeral,omitempty"`
		ID        string           `json:"id"`
		ParentID  *string          `json:"parentId"`
		Timestamp time.Time        `json:"timestamp"`
		Type      SessionEventType `json:"type"`
	}
	var raw rawEvent
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	e.AgentID = raw.AgentID
	e.Ephemeral = raw.Ephemeral
	e.ID = raw.ID
	e.ParentID = raw.ParentID
	e.Timestamp = raw.Timestamp

	switch raw.Type {
	case SessionEventTypeAbort:
		var d AbortData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeAgentInterrupted:
		var d AgentInterruptedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeAssistantFusionPhaseActivity:
		var d AssistantFusionPhaseActivityData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeAssistantFusionPhaseCompleted:
		var d AssistantFusionPhaseCompletedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeAssistantFusionPhaseFailed:
		var d AssistantFusionPhaseFailedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeAssistantFusionPhaseStarted:
		var d AssistantFusionPhaseStartedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeAssistantIdle:
		var d AssistantIdleData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeAssistantIntent:
		var d AssistantIntentData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeAssistantMessage:
		var d AssistantMessageData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeAssistantMessageDelta:
		var d AssistantMessageDeltaData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeAssistantMessageStart:
		var d AssistantMessageStartData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeAssistantReasoning:
		var d AssistantReasoningData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeAssistantReasoningDelta:
		var d AssistantReasoningDeltaData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeAssistantServerToolProgress:
		var d AssistantServerToolProgressData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeAssistantStreamingDelta:
		var d AssistantStreamingDeltaData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeAssistantToolCallDelta:
		var d AssistantToolCallDeltaData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeAssistantTurnEnd:
		var d AssistantTurnEndData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeAssistantTurnRetry:
		var d AssistantTurnRetryData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeAssistantTurnStart:
		var d AssistantTurnStartData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeAssistantUsage:
		var d AssistantUsageData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeAutoModeSwitchCompleted:
		var d AutoModeSwitchCompletedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeAutoModeSwitchRequested:
		var d AutoModeSwitchRequestedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeCapabilitiesChanged:
		var d CapabilitiesChangedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeCommandCompleted:
		var d CommandCompletedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeCommandExecute:
		var d CommandExecuteData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeCommandQueued:
		var d CommandQueuedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeCommandsChanged:
		var d CommandsChangedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeElicitationCompleted:
		var d ElicitationCompletedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeElicitationRequested:
		var d ElicitationRequestedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeExitPlanModeCompleted:
		var d ExitPlanModeCompletedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeExitPlanModeRequested:
		var d ExitPlanModeRequestedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeExternalToolCompleted:
		var d ExternalToolCompletedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeExternalToolRequested:
		var d ExternalToolRequestedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeHookEnd:
		var d HookEndData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeHookProgress:
		var d HookProgressData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeHookStart:
		var d HookStartData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeHumanResponseRecorded:
		var d HumanResponseRecordedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeMCPAppToolCallComplete:
		var d MCPAppToolCallCompleteData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeMCPHeadersRefreshCompleted:
		var d MCPHeadersRefreshCompletedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeMCPHeadersRefreshRequired:
		var d MCPHeadersRefreshRequiredData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeMCPOauthCompleted:
		var d MCPOauthCompletedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeMCPOauthRequired:
		var d MCPOauthRequiredData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeMCPPromptsListChanged:
		var d MCPPromptsListChangedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeMCPResourcesListChanged:
		var d MCPResourcesListChangedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeMCPToolsListChanged:
		var d MCPToolsListChangedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeModelCallFailure:
		var d ModelCallFailureData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeModelCallFinalResult:
		var d ModelCallFinalResultData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeModelCallFinished:
		var d ModelCallFinishedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeModelCallStart:
		var d ModelCallStartData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypePendingMessagesModified:
		var d PendingMessagesModifiedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypePermissionAssentDetected:
		var d PermissionAssentDetectedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypePermissionCarriedForward:
		var d PermissionCarriedForwardData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypePermissionCompleted:
		var d PermissionCompletedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypePermissionContextualAuthorization:
		var d PermissionContextualAuthorizationData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypePermissionMessageAuthorization:
		var d PermissionMessageAuthorizationData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypePermissionMessageAuthorizationDegraded:
		var d PermissionMessageAuthorizationDegradedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypePermissionMessageAuthorizationRead:
		var d PermissionMessageAuthorizationReadData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypePermissionRequested:
		var d PermissionRequestedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypePromptCacheBreak:
		var d PromptCacheBreakData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSamplingCompleted:
		var d SamplingCompletedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSamplingRequested:
		var d SamplingRequestedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSandboxDecision:
		var d SandboxDecisionData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionAutoModeResolved:
		var d SessionAutoModeResolvedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionAutopilotObjectiveChanged:
		var d SessionAutopilotObjectiveChangedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionAutoTierRecommendation:
		var d SessionAutoTierRecommendationData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionAutoTierSwitchFailed:
		var d SessionAutoTierSwitchFailedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionBackgroundTasksChanged:
		var d SessionBackgroundTasksChangedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionBinaryAsset:
		var d SessionBinaryAssetData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionCanvasClosed:
		var d SessionCanvasClosedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionCanvasOpened:
		var d SessionCanvasOpenedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionCanvasRecorded:
		var d SessionCanvasRecordedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionCanvasRegistryChanged:
		var d SessionCanvasRegistryChangedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionCanvasRemoved:
		var d SessionCanvasRemovedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionCanvasUnavailable:
		var d SessionCanvasUnavailableData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionCompactionComplete:
		var d SessionCompactionCompleteData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionCompactionStart:
		var d SessionCompactionStartData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionCompletionReceipt:
		var d SessionCompletionReceiptData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionContextChanged:
		var d SessionContextChangedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionContextCleared:
		var d SessionContextClearedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionCustomAgentsUpdated:
		var d SessionCustomAgentsUpdatedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionCustomNotification:
		var d SessionCustomNotificationData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionError:
		var d SessionErrorData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionExtensionsAttachmentsPushed:
		var d SessionExtensionsAttachmentsPushedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionExtensionsLoaded:
		var d SessionExtensionsLoadedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionFusionCompleted:
		var d SessionFusionCompletedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionFusionResolved:
		var d SessionFusionResolvedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionFusionRouteFailed:
		var d SessionFusionRouteFailedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionFusionRouteStarted:
		var d SessionFusionRouteStartedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionHandoff:
		var d SessionHandoffData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionIdle:
		var d SessionIdleData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionIndexedSearch:
		var d SessionIndexedSearchData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionInfo:
		var d SessionInfoData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionLimitsExhaustedCompleted:
		var d SessionLimitsExhaustedCompletedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionLimitsExhaustedRequested:
		var d SessionLimitsExhaustedRequestedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionManagedPluginProgress:
		var d SessionManagedPluginProgressData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionManagedSettingsEnforced:
		var d SessionManagedSettingsEnforcedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionManagedSettingsResolved:
		var d SessionManagedSettingsResolvedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionMCPServerNeedsReconnect:
		var d SessionMCPServerNeedsReconnectData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionMCPServerRemoved:
		var d SessionMCPServerRemovedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionMCPServersLoaded:
		var d SessionMCPServersLoadedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionMCPServerStatusChanged:
		var d SessionMCPServerStatusChangedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionModeChanged:
		var d SessionModeChangedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionModelChange:
		var d SessionModelChangeData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionModelDeselected:
		var d SessionModelDeselectedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionModeNoticeDelivered:
		var d SessionModeNoticeDeliveredData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionPermissionRecovery:
		var d SessionPermissionRecoveryData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionPermissionsChanged:
		var d SessionPermissionsChangedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionPlanChanged:
		var d SessionPlanChangedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionQuotaObservation:
		var d SessionQuotaObservationData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionRemoteSteerableChanged:
		var d SessionRemoteSteerableChangedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionResume:
		var d SessionResumeData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionScheduleCancelled:
		var d SessionScheduleCancelledData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionScheduleCreated:
		var d SessionScheduleCreatedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionScheduleRearmed:
		var d SessionScheduleRearmedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionSessionLimitsChanged:
		var d SessionSessionLimitsChangedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionShutdown:
		var d SessionShutdownData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionSkillsLoaded:
		var d SessionSkillsLoadedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionSnapshotRewind:
		var d SessionSnapshotRewindData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionStart:
		var d SessionStartData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionTaskComplete:
		var d SessionTaskCompleteData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionTitleChanged:
		var d SessionTitleChangedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionTodosChanged:
		var d SessionTodosChangedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionToolsUpdated:
		var d SessionToolsUpdatedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionTruncation:
		var d SessionTruncationData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionUsageCheckpoint:
		var d SessionUsageCheckpointData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionUsageInfo:
		var d SessionUsageInfoData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionWarning:
		var d SessionWarningData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSessionWorkspaceFileChanged:
		var d SessionWorkspaceFileChangedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSkillContextDelivered:
		var d SkillContextDeliveredData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSkillContextDeliveredRef:
		var d SkillContextDeliveredRefData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSkillInvoked:
		var d SkillInvokedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSkillInvokedRef:
		var d SkillInvokedRefData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSubagentCompleted:
		var d SubagentCompletedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSubagentConfigured:
		var d SubagentConfiguredData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSubagentDeselected:
		var d SubagentDeselectedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSubagentFailed:
		var d SubagentFailedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSubagentSelected:
		var d SubagentSelectedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSubagentStarted:
		var d SubagentStartedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSystemMessage:
		var d SystemMessageData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeSystemNotification:
		var d SystemNotificationData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeToolExecutionComplete:
		var d ToolExecutionCompleteData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeToolExecutionPartialResult:
		var d ToolExecutionPartialResultData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeToolExecutionProgress:
		var d ToolExecutionProgressData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeToolExecutionStart:
		var d ToolExecutionStartData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeToolSearchActivated:
		var d ToolSearchActivatedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeToolShellOutput:
		var d ToolShellOutputData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeToolUserRequested:
		var d ToolUserRequestedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeUIEphemeralQuery:
		var d UIEphemeralQueryData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeUserInputCompleted:
		var d UserInputCompletedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeUserInputRequested:
		var d UserInputRequestedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeUserMessage:
		var d UserMessageData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeWorkflowRunSettled:
		var d WorkflowRunSettledData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeWorkflowRunStarted:
		var d WorkflowRunStartedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	case SessionEventTypeWorkflowRunUpdated:
		var d WorkflowRunUpdatedData
		if err := json.Unmarshal(raw.Data, &d); err != nil {
			return err
		}
		e.Data = &d
	default:
		e.Data = &RawSessionEventData{EventType: raw.Type, Raw: raw.Data}
	}
	return nil
}

func (e SessionEvent) MarshalJSON() ([]byte, error) {
	type rawEvent struct {
		AgentID   *string          `json:"agentId,omitempty"`
		Data      any              `json:"data"`
		Ephemeral *bool            `json:"ephemeral,omitempty"`
		ID        string           `json:"id"`
		ParentID  *string          `json:"parentId"`
		Timestamp time.Time        `json:"timestamp"`
		Type      SessionEventType `json:"type"`
	}
	return json.Marshal(rawEvent{
		AgentID:   e.AgentID,
		Data:      e.Data,
		Ephemeral: e.Ephemeral,
		ID:        e.ID,
		ParentID:  e.ParentID,
		Timestamp: e.Timestamp,
		Type:      e.Type(),
	})
}

// MarshalJSON returns the original raw JSON so round-tripping preserves the payload.
func (r RawSessionEventData) MarshalJSON() ([]byte, error) {
	if r.Raw == nil {
		return []byte("null"), nil
	}
	return r.Raw, nil
}

func (r SessionIndexedSearchData) MarshalJSON() ([]byte, error) {
	return json.Marshal(r.Raw)
}

func (r *SessionIndexedSearchData) UnmarshalJSON(data []byte) error {
	return json.Unmarshal(data, &r.Raw)
}

func (r *UserMessageData) UnmarshalJSON(data []byte) error {
	type rawUserMessageData struct {
		AgentMode                        *UserMessageAgentMode `json:"agentMode,omitempty"`
		Attachments                      []json.RawMessage     `json:"attachments,omitzero"`
		Content                          string                `json:"content"`
		Delivery                         *UserMessageDelivery  `json:"delivery,omitempty"`
		InteractionID                    *string               `json:"interactionId,omitempty"`
		IsAutopilotContinuation          *bool                 `json:"isAutopilotContinuation,omitempty"`
		MessageID                        *string               `json:"messageId,omitempty"`
		NativeDocumentPathFallbackPaths  []string              `json:"nativeDocumentPathFallbackPaths,omitzero"`
		ParentAgentTaskID                *string               `json:"parentAgentTaskId,omitempty"`
		ResponsesReasoning               *ResponsesReasoning   `json:"responsesReasoning,omitempty"`
		Source                           *string               `json:"source,omitempty"`
		SupportedNativeDocumentMIMETypes []string              `json:"supportedNativeDocumentMimeTypes,omitzero"`
		TransformedContent               *string               `json:"transformedContent,omitempty"`
		TurnID                           *string               `json:"turnId,omitempty"`
	}
	var raw rawUserMessageData
	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.Content = raw.Content
	r.Delivery = raw.Delivery
	r.InteractionID = raw.InteractionID
	r.IsAutopilotContinuation = raw.IsAutopilotContinuation
	r.MessageID = raw.MessageID
	r.NativeDocumentPathFallbackPaths = raw.NativeDocumentPathFallbackPaths
	r.ParentAgentTaskID = raw.ParentAgentTaskID
	r.ResponsesReasoning = raw.ResponsesReasoning
	r.Source = raw.Source
	r.SupportedNativeDocumentMIMETypes = raw.SupportedNativeDocumentMIMETypes
	r.TransformedContent = raw.TransformedContent
	r.TurnID = raw.TurnID
	return nil
}

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

	switch raw.Type {
	case CitationLocationTypeBlock:
		var d CitationLocationBlock
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case CitationLocationTypeChar:
		var d CitationLocationChar
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case CitationLocationTypePage:
		var d CitationLocationPage
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	default:
		return &RawCitationLocation{Discriminator: raw.Type, Raw: data}, nil
	}
}

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

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

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

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

func (r *CitationReference) UnmarshalJSON(data []byte) error {
	type rawCitationReference struct {
		CitedText        *string         `json:"citedText,omitempty"`
		Location         json.RawMessage `json:"location,omitempty"`
		ProviderMetadata any             `json:"providerMetadata,omitempty"`
		SourceID         string          `json:"sourceId"`
	}
	var raw rawCitationReference
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	r.CitedText = raw.CitedText
	if raw.Location != nil {
		value, err := unmarshalCitationLocation(raw.Location)
		if err != nil {
			return err
		}
		r.Location = value
	}
	r.ProviderMetadata = raw.ProviderMetadata
	r.SourceID = raw.SourceID
	return nil
}

func matchesPersistedBinaryResultBinaryAssetReference(data []byte) bool {
	var rawGroup0 struct {
		AssetID       json.RawMessage `json:"assetId"`
		ByteLength    json.RawMessage `json:"byteLength"`
		Data          json.RawMessage `json:"data"`
		OmittedReason json.RawMessage `json:"omittedReason"`
	}
	if err := json.Unmarshal(data, &rawGroup0); err != nil {
		return false
	}
	if rawGroup0.AssetID == nil {
		return false
	}
	if rawGroup0.ByteLength == nil {
		return false
	}
	if rawGroup0.Data != nil {
		return false
	}
	return rawGroup0.OmittedReason == nil
}

func matchesPersistedBinaryResultOmittedBinaryResult(data []byte) bool {
	var rawGroup0 struct {
		AssetID       json.RawMessage `json:"assetId"`
		ByteLength    json.RawMessage `json:"byteLength"`
		Data          json.RawMessage `json:"data"`
		OmittedReason json.RawMessage `json:"omittedReason"`
	}
	if err := json.Unmarshal(data, &rawGroup0); err != nil {
		return false
	}
	if rawGroup0.ByteLength == nil {
		return false
	}
	if rawGroup0.OmittedReason == nil {
		return false
	}
	if rawGroup0.AssetID != nil {
		return false
	}
	return rawGroup0.Data == nil
}

func matchesPersistedBinaryResultPersistedBinaryImage(data []byte) bool {
	var rawGroup0 struct {
		AssetID       json.RawMessage `json:"assetId"`
		ByteLength    json.RawMessage `json:"byteLength"`
		Data          json.RawMessage `json:"data"`
		OmittedReason json.RawMessage `json:"omittedReason"`
	}
	if err := json.Unmarshal(data, &rawGroup0); err != nil {
		return false
	}
	if rawGroup0.Data == nil {
		return false
	}
	if rawGroup0.AssetID != nil {
		return false
	}
	if rawGroup0.ByteLength != nil {
		return false
	}
	return rawGroup0.OmittedReason == nil
}

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

	switch raw.Type {
	case PersistedBinaryResultTypeImage:
		if matchesPersistedBinaryResultBinaryAssetReference(data) {
			var d BinaryAssetReference
			if err := json.Unmarshal(data, &d); err != nil {
				return nil, err
			}
			return &d, nil
		}
		if matchesPersistedBinaryResultOmittedBinaryResult(data) {
			var d OmittedBinaryResult
			if err := json.Unmarshal(data, &d); err != nil {
				return nil, err
			}
			return &d, nil
		}
		if matchesPersistedBinaryResultPersistedBinaryImage(data) {
			var d PersistedBinaryImage
			if err := json.Unmarshal(data, &d); err != nil {
				return nil, err
			}
			return &d, nil
		}
		return &RawPersistedBinaryResult{Discriminator: raw.Type, Raw: data}, nil
	case PersistedBinaryResultTypeResource:
		if matchesPersistedBinaryResultBinaryAssetReference(data) {
			var d BinaryAssetReference
			if err := json.Unmarshal(data, &d); err != nil {
				return nil, err
			}
			return &d, nil
		}
		if matchesPersistedBinaryResultOmittedBinaryResult(data) {
			var d OmittedBinaryResult
			if err := json.Unmarshal(data, &d); err != nil {
				return nil, err
			}
			return &d, nil
		}
		if matchesPersistedBinaryResultPersistedBinaryImage(data) {
			var d PersistedBinaryImage
			if err := json.Unmarshal(data, &d); err != nil {
				return nil, err
			}
			return &d, nil
		}
		return &RawPersistedBinaryResult{Discriminator: raw.Type, Raw: data}, nil
	default:
		return &RawPersistedBinaryResult{Discriminator: raw.Type, Raw: data}, nil
	}
}

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

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

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

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

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

	switch raw.Type {
	case ToolExecutionCompleteContentTypeAudio:
		var d ToolExecutionCompleteContentAudio
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case ToolExecutionCompleteContentTypeImage:
		var d ToolExecutionCompleteContentImage
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case ToolExecutionCompleteContentTypeResource:
		var d ToolExecutionCompleteContentResource
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case ToolExecutionCompleteContentTypeResourceLink:
		var d ToolExecutionCompleteContentResourceLink
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case ToolExecutionCompleteContentTypeShellExit:
		var d ToolExecutionCompleteContentShellExit
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case ToolExecutionCompleteContentTypeTerminal:
		var d ToolExecutionCompleteContentTerminal
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case ToolExecutionCompleteContentTypeText:
		var d ToolExecutionCompleteContentText
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	default:
		return &RawToolExecutionCompleteContent{Discriminator: raw.Type, Raw: data}, nil
	}
}

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

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

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

func matchesToolExecutionCompleteContentResourceDetailsEmbeddedBlobResourceContents(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 matchesToolExecutionCompleteContentResourceDetailsEmbeddedTextResourceContents(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 (r ToolExecutionCompleteContentResourceDetails) MarshalJSON() ([]byte, error) {
	if r.EmbeddedBlobResourceContents != nil {
		return json.Marshal(r.EmbeddedBlobResourceContents)
	}
	if r.EmbeddedTextResourceContents != nil {
		return json.Marshal(r.EmbeddedTextResourceContents)
	}
	return []byte("null"), nil
}

func (r *ToolExecutionCompleteContentResourceDetails) UnmarshalJSON(data []byte) error {
	if string(data) == "null" {
		*r = ToolExecutionCompleteContentResourceDetails{}
		return nil
	}
	if matchesToolExecutionCompleteContentResourceDetailsEmbeddedBlobResourceContents(data) {
		var value EmbeddedBlobResourceContents
		if err := json.Unmarshal(data, &value); err != nil {
			return err
		}
		*r = ToolExecutionCompleteContentResourceDetails{EmbeddedBlobResourceContents: &value}
		return nil
	}
	if matchesToolExecutionCompleteContentResourceDetailsEmbeddedTextResourceContents(data) {
		var value EmbeddedTextResourceContents
		if err := json.Unmarshal(data, &value); err != nil {
			return err
		}
		*r = ToolExecutionCompleteContentResourceDetails{EmbeddedTextResourceContents: &value}
		return nil
	}
	return errors.New("data did not match any union variant for ToolExecutionCompleteContentResourceDetails")
}

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

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

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

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

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

func (r *ToolExecutionCompleteResult) UnmarshalJSON(data []byte) error {
	type rawToolExecutionCompleteResult struct {
		BinaryResultsForLlm []json.RawMessage                `json:"binaryResultsForLlm,omitzero"`
		CitableSources      []CitableSource                  `json:"citableSources,omitzero"`
		Content             string                           `json:"content"`
		Contents            []json.RawMessage                `json:"contents,omitzero"`
		DetailedContent     *string                          `json:"detailedContent,omitempty"`
		MCPMeta             any                              `json:"mcpMeta,omitempty"`
		StructuredContent   any                              `json:"structuredContent,omitempty"`
		UIResource          *ToolExecutionCompleteUIResource `json:"uiResource,omitempty"`
	}
	var raw rawToolExecutionCompleteResult
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	if raw.BinaryResultsForLlm != nil {
		r.BinaryResultsForLlm = make([]PersistedBinaryResult, 0, len(raw.BinaryResultsForLlm))
		for _, rawItem := range raw.BinaryResultsForLlm {
			value, err := unmarshalPersistedBinaryResult(rawItem)
			if err != nil {
				return err
			}
			r.BinaryResultsForLlm = append(r.BinaryResultsForLlm, value)
		}
	}
	r.CitableSources = raw.CitableSources
	r.Content = raw.Content
	if raw.Contents != nil {
		r.Contents = make([]ToolExecutionCompleteContent, 0, len(raw.Contents))
		for _, rawItem := range raw.Contents {
			value, err := unmarshalToolExecutionCompleteContent(rawItem)
			if err != nil {
				return err
			}
			r.Contents = append(r.Contents, value)
		}
	}
	r.DetailedContent = raw.DetailedContent
	r.MCPMeta = raw.MCPMeta
	r.StructuredContent = raw.StructuredContent
	r.UIResource = raw.UIResource
	return nil
}

func (r SandboxDecisionData) MarshalJSON() ([]byte, error) {
	return json.Marshal(r.Raw)
}

func (r *SandboxDecisionData) UnmarshalJSON(data []byte) error {
	return json.Unmarshal(data, &r.Raw)
}

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

	switch raw.Type {
	case SystemNotificationTypeAgentCompleted:
		var d SystemNotificationAgentCompleted
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case SystemNotificationTypeAgentIdle:
		var d SystemNotificationAgentIdle
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case SystemNotificationTypeInstructionDiscovered:
		var d SystemNotificationInstructionDiscovered
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case SystemNotificationTypeNewInboxMessage:
		var d SystemNotificationNewInboxMessage
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case SystemNotificationTypeShellCompleted:
		var d SystemNotificationShellCompleted
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case SystemNotificationTypeShellDetachedCompleted:
		var d SystemNotificationShellDetachedCompleted
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case SystemNotificationTypeUnclassified:
		var d SystemNotificationUnclassified
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case SystemNotificationTypeWorkflowCompleted:
		var d SystemNotificationWorkflowCompleted
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	default:
		return &RawSystemNotification{Discriminator: raw.Type, Raw: data}, nil
	}
}

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

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

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

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

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

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

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

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

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

	switch raw.Type {
	case SystemNotificationWorkflowPauseInfoTypeCheckpoint:
		var d SystemNotificationWorkflowPauseInfoCheckpoint
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case SystemNotificationWorkflowPauseInfoTypeUser:
		var d SystemNotificationWorkflowPauseInfoUser
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	default:
		return &RawSystemNotificationWorkflowPauseInfo{Discriminator: raw.Type, Raw: data}, nil
	}
}

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

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

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

func (r *SystemNotificationWorkflowCompleted) UnmarshalJSON(data []byte) error {
	type rawSystemNotificationWorkflowCompleted struct {
		Attempt           int64                                     `json:"attempt"`
		ConsumedNanoAiu   int64                                     `json:"consumedNanoAiu"`
		ConsumedSubagents int64                                     `json:"consumedSubagents"`
		ElapsedMs         int64                                     `json:"elapsedMs"`
		Failure           any                                       `json:"failure,omitempty"`
		PauseInfo         json.RawMessage                           `json:"pauseInfo,omitempty"`
		ResultPreview     *string                                   `json:"resultPreview,omitempty"`
		RetryGuidance     *string                                   `json:"retryGuidance,omitempty"`
		RunID             string                                    `json:"runId"`
		Status            SystemNotificationWorkflowCompletedStatus `json:"status"`
		WorkflowName      string                                    `json:"workflowName"`
	}
	var raw rawSystemNotificationWorkflowCompleted
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	r.Attempt = raw.Attempt
	r.ConsumedNanoAiu = raw.ConsumedNanoAiu
	r.ConsumedSubagents = raw.ConsumedSubagents
	r.ElapsedMs = raw.ElapsedMs
	r.Failure = raw.Failure
	if raw.PauseInfo != nil {
		value, err := unmarshalSystemNotificationWorkflowPauseInfo(raw.PauseInfo)
		if err != nil {
			return err
		}
		r.PauseInfo = value
	}
	r.ResultPreview = raw.ResultPreview
	r.RetryGuidance = raw.RetryGuidance
	r.RunID = raw.RunID
	r.Status = raw.Status
	r.WorkflowName = raw.WorkflowName
	return nil
}

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

func (r *SystemNotificationData) UnmarshalJSON(data []byte) error {
	type rawSystemNotificationData struct {
		Content            string              `json:"content"`
		Kind               json.RawMessage     `json:"kind"`
		ResponsesReasoning *ResponsesReasoning `json:"responsesReasoning,omitempty"`
	}
	var raw rawSystemNotificationData
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	r.Content = raw.Content
	if raw.Kind != nil {
		value, err := unmarshalSystemNotification(raw.Kind)
		if err != nil {
			return err
		}
		r.Kind = value
	}
	r.ResponsesReasoning = raw.ResponsesReasoning
	return nil
}

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

	switch raw.Kind {
	case PermissionRequestKindCustomTool:
		var d PermissionRequestCustomTool
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionRequestKindExtensionEnvAccess:
		var d PermissionRequestExtensionEnvAccess
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionRequestKindExtensionManagement:
		var d PermissionRequestExtensionManagement
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionRequestKindExtensionPermissionAccess:
		var d PermissionRequestExtensionPermissionAccess
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionRequestKindHook:
		var d PermissionRequestHook
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionRequestKindMCP:
		var d PermissionRequestMCP
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionRequestKindMemory:
		var d PermissionRequestMemory
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionRequestKindRead:
		var d PermissionRequestRead
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionRequestKindShell:
		var d PermissionRequestShell
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionRequestKindURL:
		var d PermissionRequestURL
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionRequestKindWorkflow:
		var d PermissionRequestWorkflow
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionRequestKindWrite:
		var d PermissionRequestWrite
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	default:
		return &RawPermissionRequest{Discriminator: raw.Kind, Raw: data}, nil
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	switch raw.Kind {
	case PermissionPromptRequestKindCommands:
		var d PermissionPromptRequestCommands
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionPromptRequestKindCustomTool:
		var d PermissionPromptRequestCustomTool
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionPromptRequestKindExtensionEnvAccess:
		var d PermissionPromptRequestExtensionEnvAccess
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionPromptRequestKindExtensionManagement:
		var d PermissionPromptRequestExtensionManagement
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionPromptRequestKindExtensionPermissionAccess:
		var d PermissionPromptRequestExtensionPermissionAccess
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionPromptRequestKindHook:
		var d PermissionPromptRequestHook
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionPromptRequestKindMCP:
		var d PermissionPromptRequestMCP
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionPromptRequestKindMemory:
		var d PermissionPromptRequestMemory
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionPromptRequestKindPath:
		var d PermissionPromptRequestPath
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionPromptRequestKindRead:
		var d PermissionPromptRequestRead
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionPromptRequestKindURL:
		var d PermissionPromptRequestURL
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionPromptRequestKindWorkflow:
		var d PermissionPromptRequestWorkflow
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionPromptRequestKindWrite:
		var d PermissionPromptRequestWrite
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	default:
		return &RawPermissionPromptRequest{Discriminator: raw.Kind, Raw: data}, nil
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (r *PermissionRequestedData) UnmarshalJSON(data []byte) error {
	type rawPermissionRequestedData struct {
		AgentMode         *SessionMode    `json:"agentMode,omitempty"`
		PermissionMode    *PermissionMode `json:"permissionMode,omitempty"`
		PermissionRequest json.RawMessage `json:"permissionRequest"`
		PromptRequest     json.RawMessage `json:"promptRequest,omitempty"`
		RecoveryEpisodeID *string         `json:"recoveryEpisodeId,omitempty"`
		RequestID         string          `json:"requestId"`
		ResolvedByHook    *bool           `json:"resolvedByHook,omitempty"`
		RiskAssessment    any             `json:"riskAssessment,omitempty"`
	}
	var raw rawPermissionRequestedData
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	r.AgentMode = raw.AgentMode
	r.PermissionMode = raw.PermissionMode
	if raw.PermissionRequest != nil {
		value, err := unmarshalPermissionRequest(raw.PermissionRequest)
		if err != nil {
			return err
		}
		r.PermissionRequest = value
	}
	if raw.PromptRequest != nil {
		value, err := unmarshalPermissionPromptRequest(raw.PromptRequest)
		if err != nil {
			return err
		}
		r.PromptRequest = value
	}
	r.RecoveryEpisodeID = raw.RecoveryEpisodeID
	r.RequestID = raw.RequestID
	r.ResolvedByHook = raw.ResolvedByHook
	r.RiskAssessment = raw.RiskAssessment
	return nil
}

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

	switch raw.Kind {
	case PermissionResultKindApproved:
		var d PermissionApproved
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionResultKindApprovedForLocation:
		var d PermissionApprovedForLocation
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionResultKindApprovedForSession:
		var d PermissionApprovedForSession
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionResultKindApprovedReadOnlyForSession:
		var d PermissionApprovedReadOnlyForSession
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionResultKindCancelled:
		var d PermissionCancelled
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionResultKindDeniedByContentExclusionPolicy:
		var d PermissionDeniedByContentExclusionPolicy
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionResultKindDeniedByPermissionRequestHook:
		var d PermissionDeniedByPermissionRequestHook
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionResultKindDeniedByRules:
		var d PermissionDeniedByRules
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionResultKindDeniedInteractivelyByUser:
		var d PermissionDeniedInteractivelyByUser
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case PermissionResultKindDeniedNoApprovalRuleAndCouldNotRequestFromUser:
		var d PermissionDeniedNoApprovalRuleAndCouldNotRequestFromUser
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	default:
		return &RawPermissionResult{Discriminator: raw.Kind, Raw: data}, nil
	}
}

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

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

func (r *PermissionApprovedForLocation) UnmarshalJSON(data []byte) error {
	type rawPermissionApprovedForLocation struct {
		Approval               json.RawMessage `json:"approval"`
		LocationKey            string          `json:"locationKey"`
		ManagedApprovalHandled *bool           `json:"managedApprovalHandled,omitempty"`
	}
	var raw rawPermissionApprovedForLocation
	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
	r.ManagedApprovalHandled = raw.ManagedApprovalHandled
	return nil
}

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

func (r *PermissionApprovedForSession) UnmarshalJSON(data []byte) error {
	type rawPermissionApprovedForSession struct {
		Approval               json.RawMessage `json:"approval"`
		ManagedApprovalHandled *bool           `json:"managedApprovalHandled,omitempty"`
	}
	var raw rawPermissionApprovedForSession
	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.ManagedApprovalHandled = raw.ManagedApprovalHandled
	return nil
}

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

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

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

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

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

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

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

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

func (r *PermissionCompletedData) UnmarshalJSON(data []byte) error {
	type rawPermissionCompletedData struct {
		Blocker           *TaskBlocker              `json:"blocker,omitempty"`
		DecisionSource    *PermissionDecisionSource `json:"decisionSource,omitempty"`
		RecoveryEpisodeID *string                   `json:"recoveryEpisodeId,omitempty"`
		RequestID         string                    `json:"requestId"`
		Result            json.RawMessage           `json:"result"`
		ToolCallID        *string                   `json:"toolCallId,omitempty"`
	}
	var raw rawPermissionCompletedData
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	r.Blocker = raw.Blocker
	r.DecisionSource = raw.DecisionSource
	r.RecoveryEpisodeID = raw.RecoveryEpisodeID
	r.RequestID = raw.RequestID
	if raw.Result != nil {
		value, err := unmarshalPermissionResult(raw.Result)
		if err != nil {
			return err
		}
		r.Result = value
	}
	r.ToolCallID = raw.ToolCallID
	return nil
}

func unmarshalHumanResponseRecordedResponse(data []byte) (HumanResponseRecordedResponse, error) {
	if string(data) == "null" {
		return nil, nil
	}
	type rawUnion struct {
		ResponseKind HumanResponseRecordedResponseResponseKind `json:"responseKind"`
	}
	var raw rawUnion
	if err := json.Unmarshal(data, &raw); err != nil {
		return nil, err
	}

	switch raw.ResponseKind {
	case HumanResponseRecordedResponseResponseKindAskUser:
		var d HumanResponseRecordedResponseAskUser
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case HumanResponseRecordedResponseResponseKindExitPlanMode:
		var d HumanResponseRecordedResponseExitPlanMode
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	case HumanResponseRecordedResponseResponseKindUserInput:
		var d HumanResponseRecordedResponseUserInput
		if err := json.Unmarshal(data, &d); err != nil {
			return nil, err
		}
		return &d, nil
	default:
		return &RawHumanResponseRecordedResponse{Discriminator: raw.ResponseKind, Raw: data}, nil
	}
}

func (r RawHumanResponseRecordedResponse) MarshalJSON() ([]byte, error) {
	if r.Raw != nil {
		return r.Raw, nil
	}
	return json.Marshal(struct {
		ResponseKind HumanResponseRecordedResponseResponseKind `json:"responseKind"`
	}{
		ResponseKind: r.Discriminator,
	})
}

func (r HumanResponseRecordedResponseAskUser) MarshalJSON() ([]byte, error) {
	type alias HumanResponseRecordedResponseAskUser
	return json.Marshal(struct {
		ResponseKind HumanResponseRecordedResponseResponseKind `json:"responseKind"`
		alias
	}{
		ResponseKind: r.ResponseKind(),
		alias:        alias(r),
	})
}

func (r HumanResponseRecordedResponseExitPlanMode) MarshalJSON() ([]byte, error) {
	type alias HumanResponseRecordedResponseExitPlanMode
	return json.Marshal(struct {
		ResponseKind HumanResponseRecordedResponseResponseKind `json:"responseKind"`
		alias
	}{
		ResponseKind: r.ResponseKind(),
		alias:        alias(r),
	})
}

func (r HumanResponseRecordedResponseUserInput) MarshalJSON() ([]byte, error) {
	type alias HumanResponseRecordedResponseUserInput
	return json.Marshal(struct {
		ResponseKind HumanResponseRecordedResponseResponseKind `json:"responseKind"`
		alias
	}{
		ResponseKind: r.ResponseKind(),
		alias:        alias(r),
	})
}

func (r *HumanResponseRecordedData) UnmarshalJSON(data []byte) error {
	type rawHumanResponseRecordedData struct {
		Actor      HumanResponseActor `json:"actor"`
		RequestID  string             `json:"requestId"`
		Response   json.RawMessage    `json:"response"`
		ToolCallID *string            `json:"toolCallId,omitempty"`
	}
	var raw rawHumanResponseRecordedData
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}
	r.Actor = raw.Actor
	r.RequestID = raw.RequestID
	if raw.Response != nil {
		value, err := unmarshalHumanResponseRecordedResponse(raw.Response)
		if err != nil {
			return err
		}
		r.Response = value
	}
	r.ToolCallID = raw.ToolCallID
	return nil
}

func (r *SessionExtensionsAttachmentsPushedData) UnmarshalJSON(data []byte) error {
	type rawSessionExtensionsAttachmentsPushedData struct {
		Attachments []json.RawMessage `json:"attachments"`
	}
	var raw rawSessionExtensionsAttachmentsPushedData
	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)
		}
	}
	return nil
}