/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *--------------------------------------------------------------------------------------------*/

// AUTO-GENERATED FILE - DO NOT EDIT
// Generated from: session-events.schema.json

#pragma warning disable CS0612 // Type or member is obsolete
#pragma warning disable CS0618 // Type or member is obsolete (with message)

using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Text.Json;
using System.Text.Json.Serialization;

namespace GitHub.Copilot;

/// <summary>
/// Provides the base class from which all session events derive.
/// </summary>
[DebuggerDisplay("{DebuggerDisplay,nq}")]
[JsonPolymorphic(
    TypeDiscriminatorPropertyName = "type",
    IgnoreUnrecognizedTypeDiscriminators = true)]
[JsonDerivedType(typeof(AbortEvent), "abort")]
[JsonDerivedType(typeof(AgentInterruptedEvent), "agent.interrupted")]
[JsonDerivedType(typeof(AssistantFusionPhaseActivityEvent), "assistant.fusion_phase_activity")]
[JsonDerivedType(typeof(AssistantFusionPhaseCompletedEvent), "assistant.fusion_phase_completed")]
[JsonDerivedType(typeof(AssistantFusionPhaseFailedEvent), "assistant.fusion_phase_failed")]
[JsonDerivedType(typeof(AssistantFusionPhaseStartedEvent), "assistant.fusion_phase_started")]
[JsonDerivedType(typeof(AssistantIdleEvent), "assistant.idle")]
[JsonDerivedType(typeof(AssistantIntentEvent), "assistant.intent")]
[JsonDerivedType(typeof(AssistantMessageEvent), "assistant.message")]
[JsonDerivedType(typeof(AssistantMessageDeltaEvent), "assistant.message_delta")]
[JsonDerivedType(typeof(AssistantMessageStartEvent), "assistant.message_start")]
[JsonDerivedType(typeof(AssistantReasoningEvent), "assistant.reasoning")]
[JsonDerivedType(typeof(AssistantReasoningDeltaEvent), "assistant.reasoning_delta")]
[JsonDerivedType(typeof(AssistantServerToolProgressEvent), "assistant.server_tool_progress")]
[JsonDerivedType(typeof(AssistantStreamingDeltaEvent), "assistant.streaming_delta")]
[JsonDerivedType(typeof(AssistantToolCallDeltaEvent), "assistant.tool_call_delta")]
[JsonDerivedType(typeof(AssistantTurnEndEvent), "assistant.turn_end")]
[JsonDerivedType(typeof(AssistantTurnRetryEvent), "assistant.turn_retry")]
[JsonDerivedType(typeof(AssistantTurnStartEvent), "assistant.turn_start")]
[JsonDerivedType(typeof(AssistantUsageEvent), "assistant.usage")]
[JsonDerivedType(typeof(AutoModeSwitchCompletedEvent), "auto_mode_switch.completed")]
[JsonDerivedType(typeof(AutoModeSwitchRequestedEvent), "auto_mode_switch.requested")]
[JsonDerivedType(typeof(CapabilitiesChangedEvent), "capabilities.changed")]
[JsonDerivedType(typeof(CommandCompletedEvent), "command.completed")]
[JsonDerivedType(typeof(CommandExecuteEvent), "command.execute")]
[JsonDerivedType(typeof(CommandQueuedEvent), "command.queued")]
[JsonDerivedType(typeof(CommandsChangedEvent), "commands.changed")]
[JsonDerivedType(typeof(ElicitationCompletedEvent), "elicitation.completed")]
[JsonDerivedType(typeof(ElicitationRequestedEvent), "elicitation.requested")]
[JsonDerivedType(typeof(ExitPlanModeCompletedEvent), "exit_plan_mode.completed")]
[JsonDerivedType(typeof(ExitPlanModeRequestedEvent), "exit_plan_mode.requested")]
[JsonDerivedType(typeof(ExternalToolCompletedEvent), "external_tool.completed")]
[JsonDerivedType(typeof(ExternalToolRequestedEvent), "external_tool.requested")]
[JsonDerivedType(typeof(FactoryRunSettledEvent), "factory.run_settled")]
[JsonDerivedType(typeof(FactoryRunStartedEvent), "factory.run_started")]
[JsonDerivedType(typeof(FactoryRunUpdatedEvent), "factory.run_updated")]
[JsonDerivedType(typeof(HookEndEvent), "hook.end")]
[JsonDerivedType(typeof(HookProgressEvent), "hook.progress")]
[JsonDerivedType(typeof(HookStartEvent), "hook.start")]
[JsonDerivedType(typeof(McpAppToolCallCompleteEvent), "mcp_app.tool_call_complete")]
[JsonDerivedType(typeof(McpHeadersRefreshCompletedEvent), "mcp.headers_refresh_completed")]
[JsonDerivedType(typeof(McpHeadersRefreshRequiredEvent), "mcp.headers_refresh_required")]
[JsonDerivedType(typeof(McpOauthCompletedEvent), "mcp.oauth_completed")]
[JsonDerivedType(typeof(McpOauthRequiredEvent), "mcp.oauth_required")]
[JsonDerivedType(typeof(McpPromptsListChangedEvent), "mcp.prompts.list_changed")]
[JsonDerivedType(typeof(McpResourcesListChangedEvent), "mcp.resources.list_changed")]
[JsonDerivedType(typeof(McpToolsListChangedEvent), "mcp.tools.list_changed")]
[JsonDerivedType(typeof(ModelCallFailureEvent), "model.call_failure")]
[JsonDerivedType(typeof(ModelCallFinishedEvent), "model.call_finished")]
[JsonDerivedType(typeof(ModelCallStartEvent), "model.call_start")]
[JsonDerivedType(typeof(PendingMessagesModifiedEvent), "pending_messages.modified")]
[JsonDerivedType(typeof(PermissionCompletedEvent), "permission.completed")]
[JsonDerivedType(typeof(PermissionRequestedEvent), "permission.requested")]
[JsonDerivedType(typeof(PromptCacheBreakEvent), "prompt_cache_break")]
[JsonDerivedType(typeof(SamplingCompletedEvent), "sampling.completed")]
[JsonDerivedType(typeof(SamplingRequestedEvent), "sampling.requested")]
[JsonDerivedType(typeof(SandboxDecisionEvent), "sandbox.decision")]
[JsonDerivedType(typeof(SessionLimitsExhaustedCompletedEvent), "session_limits_exhausted.completed")]
[JsonDerivedType(typeof(SessionLimitsExhaustedRequestedEvent), "session_limits_exhausted.requested")]
[JsonDerivedType(typeof(SessionAutoModeResolvedEvent), "session.auto_mode_resolved")]
[JsonDerivedType(typeof(SessionAutoTierSwitchFailedEvent), "session.auto_tier_switch_failed")]
[JsonDerivedType(typeof(SessionAutopilotObjectiveChangedEvent), "session.autopilot_objective_changed")]
[JsonDerivedType(typeof(SessionBackgroundTasksChangedEvent), "session.background_tasks_changed")]
[JsonDerivedType(typeof(SessionBinaryAssetEvent), "session.binary_asset")]
[JsonDerivedType(typeof(SessionCanvasClosedEvent), "session.canvas.closed")]
[JsonDerivedType(typeof(SessionCanvasOpenedEvent), "session.canvas.opened")]
[JsonDerivedType(typeof(SessionCanvasRecordedEvent), "session.canvas.recorded")]
[JsonDerivedType(typeof(SessionCanvasRegistryChangedEvent), "session.canvas.registry_changed")]
[JsonDerivedType(typeof(SessionCanvasRemovedEvent), "session.canvas.removed")]
[JsonDerivedType(typeof(SessionCanvasUnavailableEvent), "session.canvas.unavailable")]
[JsonDerivedType(typeof(SessionCompactionCompleteEvent), "session.compaction_complete")]
[JsonDerivedType(typeof(SessionCompactionStartEvent), "session.compaction_start")]
[JsonDerivedType(typeof(SessionCompletionReceiptEvent), "session.completion_receipt")]
[JsonDerivedType(typeof(SessionContextChangedEvent), "session.context_changed")]
[JsonDerivedType(typeof(SessionContextClearedEvent), "session.context_cleared")]
[JsonDerivedType(typeof(SessionCustomAgentsUpdatedEvent), "session.custom_agents_updated")]
[JsonDerivedType(typeof(SessionCustomNotificationEvent), "session.custom_notification")]
[JsonDerivedType(typeof(SessionErrorEvent), "session.error")]
[JsonDerivedType(typeof(SessionExtensionsLoadedEvent), "session.extensions_loaded")]
[JsonDerivedType(typeof(SessionExtensionsAttachmentsPushedEvent), "session.extensions.attachments_pushed")]
[JsonDerivedType(typeof(SessionFusionCompletedEvent), "session.fusion_completed")]
[JsonDerivedType(typeof(SessionFusionResolvedEvent), "session.fusion_resolved")]
[JsonDerivedType(typeof(SessionFusionRouteFailedEvent), "session.fusion_route_failed")]
[JsonDerivedType(typeof(SessionFusionRouteStartedEvent), "session.fusion_route_started")]
[JsonDerivedType(typeof(SessionHandoffEvent), "session.handoff")]
[JsonDerivedType(typeof(SessionIdleEvent), "session.idle")]
[JsonDerivedType(typeof(SessionInfoEvent), "session.info")]
[JsonDerivedType(typeof(SessionManagedSettingsEnforcedEvent), "session.managed_settings_enforced")]
[JsonDerivedType(typeof(SessionManagedSettingsResolvedEvent), "session.managed_settings_resolved")]
[JsonDerivedType(typeof(SessionMcpServerNeedsReconnectEvent), "session.mcp_server_needs_reconnect")]
[JsonDerivedType(typeof(SessionMcpServerRemovedEvent), "session.mcp_server_removed")]
[JsonDerivedType(typeof(SessionMcpServerStatusChangedEvent), "session.mcp_server_status_changed")]
[JsonDerivedType(typeof(SessionMcpServersLoadedEvent), "session.mcp_servers_loaded")]
[JsonDerivedType(typeof(SessionModeChangedEvent), "session.mode_changed")]
[JsonDerivedType(typeof(SessionModeNoticeDeliveredEvent), "session.mode_notice_delivered")]
[JsonDerivedType(typeof(SessionModelChangeEvent), "session.model_change")]
[JsonDerivedType(typeof(SessionPermissionsChangedEvent), "session.permissions_changed")]
[JsonDerivedType(typeof(SessionPlanChangedEvent), "session.plan_changed")]
[JsonDerivedType(typeof(SessionRemoteSteerableChangedEvent), "session.remote_steerable_changed")]
[JsonDerivedType(typeof(SessionResumeEvent), "session.resume")]
[JsonDerivedType(typeof(SessionScheduleCancelledEvent), "session.schedule_cancelled")]
[JsonDerivedType(typeof(SessionScheduleCreatedEvent), "session.schedule_created")]
[JsonDerivedType(typeof(SessionScheduleRearmedEvent), "session.schedule_rearmed")]
[JsonDerivedType(typeof(SessionSessionLimitsChangedEvent), "session.session_limits_changed")]
[JsonDerivedType(typeof(SessionShutdownEvent), "session.shutdown")]
[JsonDerivedType(typeof(SessionSkillsLoadedEvent), "session.skills_loaded")]
[JsonDerivedType(typeof(SessionSnapshotRewindEvent), "session.snapshot_rewind")]
[JsonDerivedType(typeof(SessionStartEvent), "session.start")]
[JsonDerivedType(typeof(SessionTaskCompleteEvent), "session.task_complete")]
[JsonDerivedType(typeof(SessionTitleChangedEvent), "session.title_changed")]
[JsonDerivedType(typeof(SessionTodosChangedEvent), "session.todos_changed")]
[JsonDerivedType(typeof(SessionToolsUpdatedEvent), "session.tools_updated")]
[JsonDerivedType(typeof(SessionTruncationEvent), "session.truncation")]
[JsonDerivedType(typeof(SessionUsageCheckpointEvent), "session.usage_checkpoint")]
[JsonDerivedType(typeof(SessionUsageInfoEvent), "session.usage_info")]
[JsonDerivedType(typeof(SessionWarningEvent), "session.warning")]
[JsonDerivedType(typeof(SessionWorkspaceFileChangedEvent), "session.workspace_file_changed")]
[JsonDerivedType(typeof(SkillInvokedEvent), "skill.invoked")]
[JsonDerivedType(typeof(SubagentCompletedEvent), "subagent.completed")]
[JsonDerivedType(typeof(SubagentConfiguredEvent), "subagent.configured")]
[JsonDerivedType(typeof(SubagentDeselectedEvent), "subagent.deselected")]
[JsonDerivedType(typeof(SubagentFailedEvent), "subagent.failed")]
[JsonDerivedType(typeof(SubagentSelectedEvent), "subagent.selected")]
[JsonDerivedType(typeof(SubagentStartedEvent), "subagent.started")]
[JsonDerivedType(typeof(SystemMessageEvent), "system.message")]
[JsonDerivedType(typeof(SystemNotificationEvent), "system.notification")]
[JsonDerivedType(typeof(ToolSearchActivatedEvent), "tool_search.activated")]
[JsonDerivedType(typeof(ToolExecutionCompleteEvent), "tool.execution_complete")]
[JsonDerivedType(typeof(ToolExecutionPartialResultEvent), "tool.execution_partial_result")]
[JsonDerivedType(typeof(ToolExecutionProgressEvent), "tool.execution_progress")]
[JsonDerivedType(typeof(ToolExecutionStartEvent), "tool.execution_start")]
[JsonDerivedType(typeof(ToolUserRequestedEvent), "tool.user_requested")]
[JsonDerivedType(typeof(UiEphemeralQueryEvent), "ui.ephemeral_query")]
[JsonDerivedType(typeof(UserInputCompletedEvent), "user_input.completed")]
[JsonDerivedType(typeof(UserInputRequestedEvent), "user_input.requested")]
[JsonDerivedType(typeof(UserMessageEvent), "user.message")]
public partial class SessionEvent
{
    /// <summary>Sub-agent instance identifier. Absent for events from the root/main agent and session-level events.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("agentId")]
    public string? AgentId { get; set; }

    /// <summary>When true, the event is transient and not persisted to the session event log on disk.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("ephemeral")]
    public bool? Ephemeral { get; set; }

    /// <summary>Unique event identifier (UUID v4), generated when the event is emitted.</summary>
    [JsonPropertyName("id")]
    public Guid Id { get; set; }

    /// <summary>ID of the chronologically preceding event in the session, forming a linked chain. Null for the first event.</summary>
    [JsonPropertyName("parentId")]
    public Guid? ParentId { get; set; }

    /// <summary>ISO 8601 timestamp when the event was created.</summary>
    [JsonPropertyName("timestamp")]
    public DateTimeOffset Timestamp { get; set; }

    /// <summary>
    /// The event type discriminator.
    /// </summary>
    [JsonIgnore]
    public virtual string Type => "unknown";

    /// <summary>Deserializes a JSON string into a <see cref="SessionEvent"/>.</summary>
    public static SessionEvent FromJson(string json) =>
        JsonSerializer.Deserialize(json, SessionEventsJsonContext.Default.SessionEvent)!;

    /// <summary>Serializes this event to a JSON string.</summary>
    public string ToJson() =>
        JsonSerializer.Serialize(this, SessionEventsJsonContext.Default.SessionEvent);

    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    private string DebuggerDisplay => ToJson();
}

/// <summary>Session initialization metadata including context and configuration.</summary>
/// <remarks>Represents the <c>session.start</c> event.</remarks>
public sealed partial class SessionStartEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.start";

    /// <summary>The <c>session.start</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionStartData Data { get; set; }
}

/// <summary>Session resume metadata including current context and event count.</summary>
/// <remarks>Represents the <c>session.resume</c> event.</remarks>
public sealed partial class SessionResumeEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.resume";

    /// <summary>The <c>session.resume</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionResumeData Data { get; set; }
}

/// <summary>Notifies that the session's remote steering capability has changed.</summary>
/// <remarks>Represents the <c>session.remote_steerable_changed</c> event.</remarks>
public sealed partial class SessionRemoteSteerableChangedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.remote_steerable_changed";

    /// <summary>The <c>session.remote_steerable_changed</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionRemoteSteerableChangedData Data { get; set; }
}

/// <summary>Error details for timeline display including message and optional diagnostic information.</summary>
/// <remarks>Represents the <c>session.error</c> event.</remarks>
public sealed partial class SessionErrorEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.error";

    /// <summary>The <c>session.error</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionErrorData Data { get; set; }
}

/// <summary>Payload indicating the session is idle with no background agents or attached shell commands in flight.</summary>
/// <remarks>Represents the <c>session.idle</c> event.</remarks>
public sealed partial class SessionIdleEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.idle";

    /// <summary>The <c>session.idle</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionIdleData Data { get; set; }
}

/// <summary>Session title change payload containing the new display title.</summary>
/// <remarks>Represents the <c>session.title_changed</c> event.</remarks>
public sealed partial class SessionTitleChangedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.title_changed";

    /// <summary>The <c>session.title_changed</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionTitleChangedData Data { get; set; }
}

/// <summary>Scheduled prompt registered via /every or /after.</summary>
/// <remarks>Represents the <c>session.schedule_created</c> event.</remarks>
public sealed partial class SessionScheduleCreatedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.schedule_created";

    /// <summary>The <c>session.schedule_created</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionScheduleCreatedData Data { get; set; }
}

/// <summary>Scheduled prompt cancelled from the schedule manager dialog.</summary>
/// <remarks>Represents the <c>session.schedule_cancelled</c> event.</remarks>
public sealed partial class SessionScheduleCancelledEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.schedule_cancelled";

    /// <summary>The <c>session.schedule_cancelled</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionScheduleCancelledData Data { get; set; }
}

/// <summary>Self-paced schedule re-armed for its next run.</summary>
/// <remarks>Represents the <c>session.schedule_rearmed</c> event.</remarks>
public sealed partial class SessionScheduleRearmedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.schedule_rearmed";

    /// <summary>The <c>session.schedule_rearmed</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionScheduleRearmedData Data { get; set; }
}

/// <summary>Autopilot objective state file operation details indicating what changed.</summary>
/// <remarks>Represents the <c>session.autopilot_objective_changed</c> event.</remarks>
public sealed partial class SessionAutopilotObjectiveChangedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.autopilot_objective_changed";

    /// <summary>The <c>session.autopilot_objective_changed</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionAutopilotObjectiveChangedData Data { get; set; }
}

/// <summary>Informational message for timeline display with categorization.</summary>
/// <remarks>Represents the <c>session.info</c> event.</remarks>
public sealed partial class SessionInfoEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.info";

    /// <summary>The <c>session.info</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionInfoData Data { get; set; }
}

/// <summary>Warning message for timeline display with categorization.</summary>
/// <remarks>Represents the <c>session.warning</c> event.</remarks>
public sealed partial class SessionWarningEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.warning";

    /// <summary>The <c>session.warning</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionWarningData Data { get; set; }
}

/// <summary>Model change details including previous and new model identifiers.</summary>
/// <remarks>Represents the <c>session.model_change</c> event.</remarks>
public sealed partial class SessionModelChangeEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.model_change";

    /// <summary>The <c>session.model_change</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionModelChangeData Data { get; set; }
}

/// <summary>A transient Auto preference failure emitted when the runtime cannot mint or accept a usable model and token pair. The previously effective preference remains active, so SDK clients can surface a non-blocking failure without changing their committed-tier state. This event is ephemeral and is not persisted or replayed on resume.</summary>
/// <remarks>Represents the <c>session.auto_tier_switch_failed</c> event.</remarks>
public sealed partial class SessionAutoTierSwitchFailedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.auto_tier_switch_failed";

    /// <summary>The <c>session.auto_tier_switch_failed</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionAutoTierSwitchFailedData Data { get; set; }
}

/// <summary>Agent mode change details including previous and new modes.</summary>
/// <remarks>Represents the <c>session.mode_changed</c> event.</remarks>
public sealed partial class SessionModeChangedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.mode_changed";

    /// <summary>The <c>session.mode_changed</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionModeChangedData Data { get; set; }
}

/// <summary>Records that a mode transition notice reached the model so cache-stable mode tools can remain offered across resume.</summary>
/// <remarks>Represents the <c>session.mode_notice_delivered</c> event.</remarks>
public sealed partial class SessionModeNoticeDeliveredEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.mode_notice_delivered";

    /// <summary>The <c>session.mode_notice_delivered</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionModeNoticeDeliveredData Data { get; set; }
}

/// <summary>Session limits update details. Null clears the limits.</summary>
/// <remarks>Represents the <c>session.session_limits_changed</c> event.</remarks>
public sealed partial class SessionSessionLimitsChangedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.session_limits_changed";

    /// <summary>The <c>session.session_limits_changed</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionSessionLimitsChangedData Data { get; set; }
}

/// <summary>Permission-mode transition details.</summary>
/// <remarks>Represents the <c>session.permissions_changed</c> event.</remarks>
[Experimental(Diagnostics.Experimental)]
public sealed partial class SessionPermissionsChangedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.permissions_changed";

    /// <summary>The <c>session.permissions_changed</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionPermissionsChangedData Data { get; set; }
}

/// <summary>Plan file operation details indicating what changed.</summary>
/// <remarks>Represents the <c>session.plan_changed</c> event.</remarks>
public sealed partial class SessionPlanChangedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.plan_changed";

    /// <summary>The <c>session.plan_changed</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionPlanChangedData Data { get; set; }
}

/// <summary>Signal-only event: the agent's todos or todo_deps table was written to. No payload — clients should call session.plan.readSqlTodosWithDependencies() to fetch the current state. Events arrive in order; clients can debounce on arrival if needed.</summary>
/// <remarks>Represents the <c>session.todos_changed</c> event.</remarks>
public sealed partial class SessionTodosChangedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.todos_changed";

    /// <summary>The <c>session.todos_changed</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionTodosChangedData Data { get; set; }
}

/// <summary>Workspace file change details including path and operation type.</summary>
/// <remarks>Represents the <c>session.workspace_file_changed</c> event.</remarks>
public sealed partial class SessionWorkspaceFileChangedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.workspace_file_changed";

    /// <summary>The <c>session.workspace_file_changed</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionWorkspaceFileChangedData Data { get; set; }
}

/// <summary>Session handoff metadata including source, context, and repository information.</summary>
/// <remarks>Represents the <c>session.handoff</c> event.</remarks>
public sealed partial class SessionHandoffEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.handoff";

    /// <summary>The <c>session.handoff</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionHandoffData Data { get; set; }
}

/// <summary>Conversation truncation statistics including token counts and removed content metrics.</summary>
/// <remarks>Represents the <c>session.truncation</c> event.</remarks>
public sealed partial class SessionTruncationEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.truncation";

    /// <summary>The <c>session.truncation</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionTruncationData Data { get; set; }
}

/// <summary>Session rewind details including target event and count of removed events.</summary>
/// <remarks>Represents the <c>session.snapshot_rewind</c> event.</remarks>
public sealed partial class SessionSnapshotRewindEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.snapshot_rewind";

    /// <summary>The <c>session.snapshot_rewind</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionSnapshotRewindData Data { get; set; }
}

/// <summary>Session termination metrics including usage statistics, code changes, and shutdown reason.</summary>
/// <remarks>Represents the <c>session.shutdown</c> event.</remarks>
public sealed partial class SessionShutdownEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.shutdown";

    /// <summary>The <c>session.shutdown</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionShutdownData Data { get; set; }
}

/// <summary>Durable session usage checkpoint for reconstructing aggregate accounting on resume.</summary>
/// <remarks>Represents the <c>session.usage_checkpoint</c> event.</remarks>
public sealed partial class SessionUsageCheckpointEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.usage_checkpoint";

    /// <summary>The <c>session.usage_checkpoint</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionUsageCheckpointData Data { get; set; }
}

/// <summary>Working directory and git context at session start.</summary>
/// <remarks>Represents the <c>session.context_changed</c> event.</remarks>
public sealed partial class SessionContextChangedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.context_changed";

    /// <summary>The <c>session.context_changed</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionContextChangedData Data { get; set; }
}

/// <summary>Current context window usage statistics including token and message counts.</summary>
/// <remarks>Represents the <c>session.usage_info</c> event.</remarks>
public sealed partial class SessionUsageInfoEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.usage_info";

    /// <summary>The <c>session.usage_info</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionUsageInfoData Data { get; set; }
}

/// <summary>Context-cleared details emitted when the host clears the conversation (the session.history.clearContext RPC / Session.clearContextMessages).</summary>
/// <remarks>Represents the <c>session.context_cleared</c> event.</remarks>
public sealed partial class SessionContextClearedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.context_cleared";

    /// <summary>The <c>session.context_cleared</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionContextClearedData Data { get; set; }
}

/// <summary>Context window breakdown at the start of LLM-powered conversation compaction.</summary>
/// <remarks>Represents the <c>session.compaction_start</c> event.</remarks>
public sealed partial class SessionCompactionStartEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.compaction_start";

    /// <summary>The <c>session.compaction_start</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionCompactionStartData Data { get; set; }
}

/// <summary>Conversation compaction results including success status, metrics, and optional error details.</summary>
/// <remarks>Represents the <c>session.compaction_complete</c> event.</remarks>
public sealed partial class SessionCompactionCompleteEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.compaction_complete";

    /// <summary>The <c>session.compaction_complete</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionCompactionCompleteData Data { get; set; }
}

/// <summary>Task completion notification with summary from the agent.</summary>
/// <remarks>Represents the <c>session.task_complete</c> event.</remarks>
public sealed partial class SessionTaskCompleteEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.task_complete";

    /// <summary>The <c>session.task_complete</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionTaskCompleteData Data { get; set; }
}

/// <summary>Behavior-neutral record of structured runtime facts present when an agent completion decision is accepted.</summary>
/// <remarks>Represents the <c>session.completion_receipt</c> event.</remarks>
[Experimental(Diagnostics.Experimental)]
public sealed partial class SessionCompletionReceiptEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.completion_receipt";

    /// <summary>The <c>session.completion_receipt</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionCompletionReceiptData Data { get; set; }
}

/// <summary>Experimental transient signal that HydraFusion routing has started for an eligible turn.</summary>
/// <remarks>Represents the <c>session.fusion_route_started</c> event.</remarks>
[Experimental(Diagnostics.Experimental)]
public sealed partial class SessionFusionRouteStartedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.fusion_route_started";

    /// <summary>The <c>session.fusion_route_started</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionFusionRouteStartedData Data { get; set; }
}

/// <summary>Experimental durable HydraFusion routing failure and the deterministic concrete fallback selected for the turn.</summary>
/// <remarks>Represents the <c>session.fusion_route_failed</c> event.</remarks>
[Experimental(Diagnostics.Experimental)]
public sealed partial class SessionFusionRouteFailedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.fusion_route_failed";

    /// <summary>The <c>session.fusion_route_failed</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionFusionRouteFailedData Data { get; set; }
}

/// <summary>Experimental durable validated HydraFusion route and turn policy.</summary>
/// <remarks>Represents the <c>session.fusion_resolved</c> event.</remarks>
[Experimental(Diagnostics.Experimental)]
public sealed partial class SessionFusionResolvedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.fusion_resolved";

    /// <summary>The <c>session.fusion_resolved</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionFusionResolvedData Data { get; set; }
}

/// <summary>Experimental durable aggregate outcome of a HydraFusion turn.</summary>
/// <remarks>Represents the <c>session.fusion_completed</c> event.</remarks>
[Experimental(Diagnostics.Experimental)]
public sealed partial class SessionFusionCompletedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.fusion_completed";

    /// <summary>The <c>session.fusion_completed</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionFusionCompletedData Data { get; set; }
}

/// <summary>Payload of `user.message` with displayed and model-transformed content, attachments, source/delivery metadata, mode, and telemetry IDs.</summary>
/// <remarks>Represents the <c>user.message</c> event.</remarks>
public sealed partial class UserMessageEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "user.message";

    /// <summary>The <c>user.message</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required UserMessageData Data { get; set; }
}

/// <summary>Empty payload; the event signals that the pending message queue has changed.</summary>
/// <remarks>Represents the <c>pending_messages.modified</c> event.</remarks>
public sealed partial class PendingMessagesModifiedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "pending_messages.modified";

    /// <summary>The <c>pending_messages.modified</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required PendingMessagesModifiedData Data { get; set; }
}

/// <summary>Turn initialization metadata including identifier and interaction tracking.</summary>
/// <remarks>Represents the <c>assistant.turn_start</c> event.</remarks>
public sealed partial class AssistantTurnStartEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "assistant.turn_start";

    /// <summary>The <c>assistant.turn_start</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required AssistantTurnStartData Data { get; set; }
}

/// <summary>Metadata for an additional model inference attempt within an existing assistant turn.</summary>
/// <remarks>Represents the <c>assistant.turn_retry</c> event.</remarks>
public sealed partial class AssistantTurnRetryEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "assistant.turn_retry";

    /// <summary>The <c>assistant.turn_retry</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required AssistantTurnRetryData Data { get; set; }
}

/// <summary>Metadata for work the user interrupted while the agent was running.</summary>
/// <remarks>Represents the <c>agent.interrupted</c> event.</remarks>
public sealed partial class AgentInterruptedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "agent.interrupted";

    /// <summary>The <c>agent.interrupted</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required AgentInterruptedData Data { get; set; }
}

/// <summary>Agent intent description for current activity or plan.</summary>
/// <remarks>Represents the <c>assistant.intent</c> event.</remarks>
public sealed partial class AssistantIntentEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "assistant.intent";

    /// <summary>The <c>assistant.intent</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required AssistantIntentData Data { get; set; }
}

/// <summary>Experimental transient HydraFusion phase/model/role signal.</summary>
/// <remarks>Represents the <c>assistant.fusion_phase_started</c> event.</remarks>
[Experimental(Diagnostics.Experimental)]
public sealed partial class AssistantFusionPhaseStartedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "assistant.fusion_phase_started";

    /// <summary>The <c>assistant.fusion_phase_started</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required AssistantFusionPhaseStartedData Data { get; set; }
}

/// <summary>Experimental content-safe activity signal for a running HydraFusion phase.</summary>
/// <remarks>Represents the <c>assistant.fusion_phase_activity</c> event.</remarks>
[Experimental(Diagnostics.Experimental)]
public sealed partial class AssistantFusionPhaseActivityEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "assistant.fusion_phase_activity";

    /// <summary>The <c>assistant.fusion_phase_activity</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required AssistantFusionPhaseActivityData Data { get; set; }
}

/// <summary>Experimental durable HydraFusion phase output and lossless replay checkpoint.</summary>
/// <remarks>Represents the <c>assistant.fusion_phase_completed</c> event.</remarks>
[Experimental(Diagnostics.Experimental)]
public sealed partial class AssistantFusionPhaseCompletedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "assistant.fusion_phase_completed";

    /// <summary>The <c>assistant.fusion_phase_completed</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required AssistantFusionPhaseCompletedData Data { get; set; }
}

/// <summary>Experimental durable typed HydraFusion phase failure and degradation transition.</summary>
/// <remarks>Represents the <c>assistant.fusion_phase_failed</c> event.</remarks>
[Experimental(Diagnostics.Experimental)]
public sealed partial class AssistantFusionPhaseFailedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "assistant.fusion_phase_failed";

    /// <summary>The <c>assistant.fusion_phase_failed</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required AssistantFusionPhaseFailedData Data { get; set; }
}

/// <summary>Live progress signal for a provider-hosted server tool (e.g. hosted web search) while it runs, before the finalized serverTools envelope lands on the terminal assistant.message.</summary>
/// <remarks>Represents the <c>assistant.server_tool_progress</c> event.</remarks>
public sealed partial class AssistantServerToolProgressEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "assistant.server_tool_progress";

    /// <summary>The <c>assistant.server_tool_progress</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required AssistantServerToolProgressData Data { get; set; }
}

/// <summary>Assistant reasoning content for timeline display with complete thinking text.</summary>
/// <remarks>Represents the <c>assistant.reasoning</c> event.</remarks>
public sealed partial class AssistantReasoningEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "assistant.reasoning";

    /// <summary>The <c>assistant.reasoning</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required AssistantReasoningData Data { get; set; }
}

/// <summary>Streaming reasoning delta for incremental extended thinking updates.</summary>
/// <remarks>Represents the <c>assistant.reasoning_delta</c> event.</remarks>
public sealed partial class AssistantReasoningDeltaEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "assistant.reasoning_delta";

    /// <summary>The <c>assistant.reasoning_delta</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required AssistantReasoningDeltaData Data { get; set; }
}

/// <summary>Streaming tool-call input delta for incremental tool-call updates.</summary>
/// <remarks>Represents the <c>assistant.tool_call_delta</c> event.</remarks>
public sealed partial class AssistantToolCallDeltaEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "assistant.tool_call_delta";

    /// <summary>The <c>assistant.tool_call_delta</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required AssistantToolCallDeltaData Data { get; set; }
}

/// <summary>Streaming response progress with cumulative byte count.</summary>
/// <remarks>Represents the <c>assistant.streaming_delta</c> event.</remarks>
public sealed partial class AssistantStreamingDeltaEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "assistant.streaming_delta";

    /// <summary>The <c>assistant.streaming_delta</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required AssistantStreamingDeltaData Data { get; set; }
}

/// <summary>Assistant response containing text content, optional tool requests, and interaction metadata.</summary>
/// <remarks>Represents the <c>assistant.message</c> event.</remarks>
public sealed partial class AssistantMessageEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "assistant.message";

    /// <summary>The <c>assistant.message</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required AssistantMessageData Data { get; set; }
}

/// <summary>Streaming assistant message start metadata.</summary>
/// <remarks>Represents the <c>assistant.message_start</c> event.</remarks>
public sealed partial class AssistantMessageStartEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "assistant.message_start";

    /// <summary>The <c>assistant.message_start</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required AssistantMessageStartData Data { get; set; }
}

/// <summary>Streaming assistant message delta for incremental response updates.</summary>
/// <remarks>Represents the <c>assistant.message_delta</c> event.</remarks>
public sealed partial class AssistantMessageDeltaEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "assistant.message_delta";

    /// <summary>The <c>assistant.message_delta</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required AssistantMessageDeltaData Data { get; set; }
}

/// <summary>Turn completion metadata including the turn identifier.</summary>
/// <remarks>Represents the <c>assistant.turn_end</c> event.</remarks>
public sealed partial class AssistantTurnEndEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "assistant.turn_end";

    /// <summary>The <c>assistant.turn_end</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required AssistantTurnEndData Data { get; set; }
}

/// <summary>Payload emitted whenever the main agent's processing loop goes idle, including while related background work (running agents or in-flight attached shell commands) is still pending and the session-level idle event is therefore deferred.</summary>
/// <remarks>Represents the <c>assistant.idle</c> event.</remarks>
public sealed partial class AssistantIdleEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "assistant.idle";

    /// <summary>The <c>assistant.idle</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required AssistantIdleData Data { get; set; }
}

/// <summary>LLM API call usage metrics including tokens, costs, quotas, and billing information.</summary>
/// <remarks>Represents the <c>assistant.usage</c> event.</remarks>
public sealed partial class AssistantUsageEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "assistant.usage";

    /// <summary>The <c>assistant.usage</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required AssistantUsageData Data { get; set; }
}

/// <summary>A detected loss of a previously cached prompt prefix.</summary>
/// <remarks>Represents the <c>prompt_cache_break</c> event.</remarks>
public sealed partial class PromptCacheBreakEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "prompt_cache_break";

    /// <summary>The <c>prompt_cache_break</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required PromptCacheBreakData Data { get; set; }
}

/// <summary>Failed LLM API call metadata for telemetry.</summary>
/// <remarks>Represents the <c>model.call_failure</c> event.</remarks>
public sealed partial class ModelCallFailureEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "model.call_failure";

    /// <summary>The <c>model.call_failure</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required ModelCallFailureData Data { get; set; }
}

/// <summary>Final lifecycle outcome for one logical model dispatch. A logical dispatch may include internal reconnect or fallback work, so event count is not provider HTTP-request count.</summary>
/// <remarks>Represents the <c>model.call_finished</c> event.</remarks>
public sealed partial class ModelCallFinishedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "model.call_finished";

    /// <summary>The <c>model.call_finished</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required ModelCallFinishedData Data { get; set; }
}

/// <summary>Model API dispatch metadata for internal telemetry.</summary>
/// <remarks>Represents the <c>model.call_start</c> event.</remarks>
public sealed partial class ModelCallStartEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "model.call_start";

    /// <summary>The <c>model.call_start</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required ModelCallStartData Data { get; set; }
}

/// <summary>Turn abort information including the reason for termination.</summary>
/// <remarks>Represents the <c>abort</c> event.</remarks>
public sealed partial class AbortEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "abort";

    /// <summary>The <c>abort</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required AbortData Data { get; set; }
}

/// <summary>User-initiated tool invocation request with tool name and arguments.</summary>
/// <remarks>Represents the <c>tool.user_requested</c> event.</remarks>
public sealed partial class ToolUserRequestedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "tool.user_requested";

    /// <summary>The <c>tool.user_requested</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required ToolUserRequestedData Data { get; set; }
}

/// <summary>Tool execution startup details including MCP server information when applicable.</summary>
/// <remarks>Represents the <c>tool.execution_start</c> event.</remarks>
public sealed partial class ToolExecutionStartEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "tool.execution_start";

    /// <summary>The <c>tool.execution_start</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required ToolExecutionStartData Data { get; set; }
}

/// <summary>Streaming tool execution output for incremental result display.</summary>
/// <remarks>Represents the <c>tool.execution_partial_result</c> event.</remarks>
public sealed partial class ToolExecutionPartialResultEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "tool.execution_partial_result";

    /// <summary>The <c>tool.execution_partial_result</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required ToolExecutionPartialResultData Data { get; set; }
}

/// <summary>Tool execution progress notification with status message.</summary>
/// <remarks>Represents the <c>tool.execution_progress</c> event.</remarks>
public sealed partial class ToolExecutionProgressEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "tool.execution_progress";

    /// <summary>The <c>tool.execution_progress</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required ToolExecutionProgressData Data { get; set; }
}

/// <summary>Tool execution completion results including success status, detailed output, and error information.</summary>
/// <remarks>Represents the <c>tool.execution_complete</c> event.</remarks>
public sealed partial class ToolExecutionCompleteEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "tool.execution_complete";

    /// <summary>The <c>tool.execution_complete</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required ToolExecutionCompleteData Data { get; set; }
}

/// <summary>Persisted generic client-side tool activations restored when a session resumes.</summary>
/// <remarks>Represents the <c>tool_search.activated</c> event.</remarks>
public sealed partial class ToolSearchActivatedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "tool_search.activated";

    /// <summary>The <c>tool_search.activated</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required ToolSearchActivatedData Data { get; set; }
}

/// <summary>Skill invocation details including content, allowed tools, and plugin metadata.</summary>
/// <remarks>Represents the <c>skill.invoked</c> event.</remarks>
public sealed partial class SkillInvokedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "skill.invoked";

    /// <summary>The <c>skill.invoked</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SkillInvokedData Data { get; set; }
}

/// <summary>Payload of `sandbox.decision`, a bounded governance record of what the process sandbox was configured to do and whether it took effect. Discriminated by `kind`.</summary>
/// <remarks>Represents the <c>sandbox.decision</c> event.</remarks>
public sealed partial class SandboxDecisionEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "sandbox.decision";

    /// <summary>The <c>sandbox.decision</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SandboxDecisionData Data { get; set; }
}

/// <summary>Sub-agent startup details including parent tool call and agent information.</summary>
/// <remarks>Represents the <c>subagent.started</c> event.</remarks>
public sealed partial class SubagentStartedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "subagent.started";

    /// <summary>The <c>subagent.started</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SubagentStartedData Data { get; set; }
}

/// <summary>Resolved runtime configuration for a configured sub-agent.</summary>
/// <remarks>Represents the <c>subagent.configured</c> event.</remarks>
public sealed partial class SubagentConfiguredEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "subagent.configured";

    /// <summary>The <c>subagent.configured</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SubagentConfiguredData Data { get; set; }
}

/// <summary>Sub-agent completion details for successful execution.</summary>
/// <remarks>Represents the <c>subagent.completed</c> event.</remarks>
public sealed partial class SubagentCompletedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "subagent.completed";

    /// <summary>The <c>subagent.completed</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SubagentCompletedData Data { get; set; }
}

/// <summary>Sub-agent failure details including error message and agent information.</summary>
/// <remarks>Represents the <c>subagent.failed</c> event.</remarks>
public sealed partial class SubagentFailedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "subagent.failed";

    /// <summary>The <c>subagent.failed</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SubagentFailedData Data { get; set; }
}

/// <summary>Custom agent selection details including name and available tools.</summary>
/// <remarks>Represents the <c>subagent.selected</c> event.</remarks>
public sealed partial class SubagentSelectedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "subagent.selected";

    /// <summary>The <c>subagent.selected</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SubagentSelectedData Data { get; set; }
}

/// <summary>Empty payload; the event signals that the custom agent was deselected, returning to the default agent.</summary>
/// <remarks>Represents the <c>subagent.deselected</c> event.</remarks>
public sealed partial class SubagentDeselectedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "subagent.deselected";

    /// <summary>The <c>subagent.deselected</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SubagentDeselectedData Data { get; set; }
}

/// <summary>Hook invocation start details including type and input data.</summary>
/// <remarks>Represents the <c>hook.start</c> event.</remarks>
public sealed partial class HookStartEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "hook.start";

    /// <summary>The <c>hook.start</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required HookStartData Data { get; set; }
}

/// <summary>Hook invocation completion details including output, success status, and error information.</summary>
/// <remarks>Represents the <c>hook.end</c> event.</remarks>
public sealed partial class HookEndEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "hook.end";

    /// <summary>The <c>hook.end</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required HookEndData Data { get; set; }
}

/// <summary>Ephemeral progress update from a running hook process.</summary>
/// <remarks>Represents the <c>hook.progress</c> event.</remarks>
public sealed partial class HookProgressEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "hook.progress";

    /// <summary>The <c>hook.progress</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required HookProgressData Data { get; set; }
}

/// <summary>Canonical bytes for a content-addressed binary asset shared by reference across events.</summary>
/// <remarks>Represents the <c>session.binary_asset</c> event.</remarks>
[Experimental(Diagnostics.Experimental)]
public sealed partial class SessionBinaryAssetEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.binary_asset";

    /// <summary>The <c>session.binary_asset</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionBinaryAssetData Data { get; set; }
}

/// <summary>System/developer instruction content with role and optional template metadata.</summary>
/// <remarks>Represents the <c>system.message</c> event.</remarks>
public sealed partial class SystemMessageEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "system.message";

    /// <summary>The <c>system.message</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SystemMessageData Data { get; set; }
}

/// <summary>System-generated notification for runtime events like background task completion.</summary>
/// <remarks>Represents the <c>system.notification</c> event.</remarks>
public sealed partial class SystemNotificationEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "system.notification";

    /// <summary>The <c>system.notification</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SystemNotificationData Data { get; set; }
}

/// <summary>Permission request notification requiring client approval with request details.</summary>
/// <remarks>Represents the <c>permission.requested</c> event.</remarks>
public sealed partial class PermissionRequestedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "permission.requested";

    /// <summary>The <c>permission.requested</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required PermissionRequestedData Data { get; set; }
}

/// <summary>Permission request completion notification signaling UI dismissal.</summary>
/// <remarks>Represents the <c>permission.completed</c> event.</remarks>
public sealed partial class PermissionCompletedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "permission.completed";

    /// <summary>The <c>permission.completed</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required PermissionCompletedData Data { get; set; }
}

/// <summary>User input request notification with question and optional predefined choices.</summary>
/// <remarks>Represents the <c>user_input.requested</c> event.</remarks>
public sealed partial class UserInputRequestedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "user_input.requested";

    /// <summary>The <c>user_input.requested</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required UserInputRequestedData Data { get; set; }
}

/// <summary>User input request completion with the user's response.</summary>
/// <remarks>Represents the <c>user_input.completed</c> event.</remarks>
public sealed partial class UserInputCompletedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "user_input.completed";

    /// <summary>The <c>user_input.completed</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required UserInputCompletedData Data { get; set; }
}

/// <summary>Elicitation request; may be form-based (structured input) or URL-based (browser redirect).</summary>
/// <remarks>Represents the <c>elicitation.requested</c> event.</remarks>
public sealed partial class ElicitationRequestedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "elicitation.requested";

    /// <summary>The <c>elicitation.requested</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required ElicitationRequestedData Data { get; set; }
}

/// <summary>Elicitation request completion with the user's response.</summary>
/// <remarks>Represents the <c>elicitation.completed</c> event.</remarks>
public sealed partial class ElicitationCompletedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "elicitation.completed";

    /// <summary>The <c>elicitation.completed</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required ElicitationCompletedData Data { get; set; }
}

/// <summary>Sampling request from an MCP server; contains the server name and a requestId for correlation.</summary>
/// <remarks>Represents the <c>sampling.requested</c> event.</remarks>
public sealed partial class SamplingRequestedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "sampling.requested";

    /// <summary>The <c>sampling.requested</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SamplingRequestedData Data { get; set; }
}

/// <summary>Sampling request completion notification signaling UI dismissal.</summary>
/// <remarks>Represents the <c>sampling.completed</c> event.</remarks>
public sealed partial class SamplingCompletedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "sampling.completed";

    /// <summary>The <c>sampling.completed</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SamplingCompletedData Data { get; set; }
}

/// <summary>OAuth authentication request for an MCP server.</summary>
/// <remarks>Represents the <c>mcp.oauth_required</c> event.</remarks>
public sealed partial class McpOauthRequiredEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "mcp.oauth_required";

    /// <summary>The <c>mcp.oauth_required</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required McpOauthRequiredData Data { get; set; }
}

/// <summary>MCP OAuth request completion notification.</summary>
/// <remarks>Represents the <c>mcp.oauth_completed</c> event.</remarks>
public sealed partial class McpOauthCompletedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "mcp.oauth_completed";

    /// <summary>The <c>mcp.oauth_completed</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required McpOauthCompletedData Data { get; set; }
}

/// <summary>Dynamic headers refresh request for a remote MCP server.</summary>
/// <remarks>Represents the <c>mcp.headers_refresh_required</c> event.</remarks>
public sealed partial class McpHeadersRefreshRequiredEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "mcp.headers_refresh_required";

    /// <summary>The <c>mcp.headers_refresh_required</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required McpHeadersRefreshRequiredData Data { get; set; }
}

/// <summary>MCP headers refresh request completion notification.</summary>
/// <remarks>Represents the <c>mcp.headers_refresh_completed</c> event.</remarks>
public sealed partial class McpHeadersRefreshCompletedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "mcp.headers_refresh_completed";

    /// <summary>The <c>mcp.headers_refresh_completed</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required McpHeadersRefreshCompletedData Data { get; set; }
}

/// <summary>Opaque custom notification data. Consumers may branch on source and name, but payload semantics are source-defined.</summary>
/// <remarks>Represents the <c>session.custom_notification</c> event.</remarks>
public sealed partial class SessionCustomNotificationEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.custom_notification";

    /// <summary>The <c>session.custom_notification</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionCustomNotificationData Data { get; set; }
}

/// <summary>Ordered output and terminal state for a transient query that does not modify conversation history.</summary>
/// <remarks>Represents the <c>ui.ephemeral_query</c> event.</remarks>
[Experimental(Diagnostics.Experimental)]
public sealed partial class UiEphemeralQueryEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "ui.ephemeral_query";

    /// <summary>The <c>ui.ephemeral_query</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required UiEphemeralQueryData Data { get; set; }
}

/// <summary>External tool invocation request for client-side tool execution.</summary>
/// <remarks>Represents the <c>external_tool.requested</c> event.</remarks>
public sealed partial class ExternalToolRequestedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "external_tool.requested";

    /// <summary>The <c>external_tool.requested</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required ExternalToolRequestedData Data { get; set; }
}

/// <summary>External tool completion notification signaling UI dismissal.</summary>
/// <remarks>Represents the <c>external_tool.completed</c> event.</remarks>
public sealed partial class ExternalToolCompletedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "external_tool.completed";

    /// <summary>The <c>external_tool.completed</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required ExternalToolCompletedData Data { get; set; }
}

/// <summary>Queued slash command dispatch request for client execution.</summary>
/// <remarks>Represents the <c>command.queued</c> event.</remarks>
public sealed partial class CommandQueuedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "command.queued";

    /// <summary>The <c>command.queued</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required CommandQueuedData Data { get; set; }
}

/// <summary>Registered command dispatch request routed to the owning client.</summary>
/// <remarks>Represents the <c>command.execute</c> event.</remarks>
public sealed partial class CommandExecuteEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "command.execute";

    /// <summary>The <c>command.execute</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required CommandExecuteData Data { get; set; }
}

/// <summary>Queued command completion notification signaling UI dismissal.</summary>
/// <remarks>Represents the <c>command.completed</c> event.</remarks>
public sealed partial class CommandCompletedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "command.completed";

    /// <summary>The <c>command.completed</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required CommandCompletedData Data { get; set; }
}

/// <summary>Auto mode switch request notification requiring user approval.</summary>
/// <remarks>Represents the <c>auto_mode_switch.requested</c> event.</remarks>
public sealed partial class AutoModeSwitchRequestedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "auto_mode_switch.requested";

    /// <summary>The <c>auto_mode_switch.requested</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required AutoModeSwitchRequestedData Data { get; set; }
}

/// <summary>Auto mode switch completion notification.</summary>
/// <remarks>Represents the <c>auto_mode_switch.completed</c> event.</remarks>
public sealed partial class AutoModeSwitchCompletedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "auto_mode_switch.completed";

    /// <summary>The <c>auto_mode_switch.completed</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required AutoModeSwitchCompletedData Data { get; set; }
}

/// <summary>Session limit exhaustion notification requiring user action.</summary>
/// <remarks>Represents the <c>session_limits_exhausted.requested</c> event.</remarks>
public sealed partial class SessionLimitsExhaustedRequestedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session_limits_exhausted.requested";

    /// <summary>The <c>session_limits_exhausted.requested</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionLimitsExhaustedRequestedData Data { get; set; }
}

/// <summary>Session limit exhaustion prompt completion notification.</summary>
/// <remarks>Represents the <c>session_limits_exhausted.completed</c> event.</remarks>
public sealed partial class SessionLimitsExhaustedCompletedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session_limits_exhausted.completed";

    /// <summary>The <c>session_limits_exhausted.completed</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionLimitsExhaustedCompletedData Data { get; set; }
}

/// <summary>Auto Intent resolution: the concrete model the session settled on for the first prompt of an auto-mode session, and why. Lets SDK clients render the chosen model and the full reason it was picked. The core selection fields (chosenModel/reasoningBucket/categoryScores) are stable; the routing-analytics fields (predictedLabel/confidence/candidateModels) mirror the upstream intent service and may evolve, hence the event's experimental stability.</summary>
/// <remarks>Represents the <c>session.auto_mode_resolved</c> event.</remarks>
[Experimental(Diagnostics.Experimental)]
public sealed partial class SessionAutoModeResolvedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.auto_mode_resolved";

    /// <summary>The <c>session.auto_mode_resolved</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionAutoModeResolvedData Data { get; set; }
}

/// <summary>Enterprise managed-settings resolution: the effective managed settings the session applied and which channels contributed, so SDK clients can show users what is enterprise-managed. Fires whenever managed policy is (re)applied — at session start, on resume, and on account switch. This is an ephemeral live snapshot (delivered to subscribers but not persisted to the session event log), because at session start it resolves before `session.start` is emitted. Device values take precedence over server values, then the policy helper, per ordinary key, while permissions compose restrictively across device, server, policy-helper, and SDK-client layers. The account-scoped `getManagedSettings()` API does not include session-local client injection. Marked experimental while the managed-settings surface stabilizes.</summary>
/// <remarks>Represents the <c>session.managed_settings_resolved</c> event.</remarks>
[Experimental(Diagnostics.Experimental)]
public sealed partial class SessionManagedSettingsResolvedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.managed_settings_resolved";

    /// <summary>The <c>session.managed_settings_resolved</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionManagedSettingsResolvedData Data { get; set; }
}

/// <summary>Runtime enforcement of enterprise managed settings: fires when the session blocks or caps a runtime action because enterprise policy governs it, so SDK clients can explain *why* an action was governed. Unlike `session.managed_settings_resolved` (which reports *what* is managed), this reports a concrete governed action — e.g. a user or host tried to turn on a bypass-permissions escalation while policy disables it. Emitted live (not persisted to the session event log) on user/host-initiated attempts only, never for silent policy application. Marked experimental while the managed-settings surface stabilizes.</summary>
/// <remarks>Represents the <c>session.managed_settings_enforced</c> event.</remarks>
[Experimental(Diagnostics.Experimental)]
public sealed partial class SessionManagedSettingsEnforcedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.managed_settings_enforced";

    /// <summary>The <c>session.managed_settings_enforced</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionManagedSettingsEnforcedData Data { get; set; }
}

/// <summary>SDK command registration change notification.</summary>
/// <remarks>Represents the <c>commands.changed</c> event.</remarks>
public sealed partial class CommandsChangedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "commands.changed";

    /// <summary>The <c>commands.changed</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required CommandsChangedData Data { get; set; }
}

/// <summary>Session capability change notification.</summary>
/// <remarks>Represents the <c>capabilities.changed</c> event.</remarks>
public sealed partial class CapabilitiesChangedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "capabilities.changed";

    /// <summary>The <c>capabilities.changed</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required CapabilitiesChangedData Data { get; set; }
}

/// <summary>Plan approval request with plan content and available user actions.</summary>
/// <remarks>Represents the <c>exit_plan_mode.requested</c> event.</remarks>
public sealed partial class ExitPlanModeRequestedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "exit_plan_mode.requested";

    /// <summary>The <c>exit_plan_mode.requested</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required ExitPlanModeRequestedData Data { get; set; }
}

/// <summary>Plan mode exit completion with the user's approval decision and optional feedback.</summary>
/// <remarks>Represents the <c>exit_plan_mode.completed</c> event.</remarks>
public sealed partial class ExitPlanModeCompletedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "exit_plan_mode.completed";

    /// <summary>The <c>exit_plan_mode.completed</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required ExitPlanModeCompletedData Data { get; set; }
}

/// <summary>Payload of `session.tools_updated` identifying the model whose resolved tools were updated.</summary>
/// <remarks>Represents the <c>session.tools_updated</c> event.</remarks>
public sealed partial class SessionToolsUpdatedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.tools_updated";

    /// <summary>The <c>session.tools_updated</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionToolsUpdatedData Data { get; set; }
}

/// <summary>Empty payload for `session.background_tasks_changed`, indicating background task state changed.</summary>
/// <remarks>Represents the <c>session.background_tasks_changed</c> event.</remarks>
public sealed partial class SessionBackgroundTasksChangedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.background_tasks_changed";

    /// <summary>The <c>session.background_tasks_changed</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionBackgroundTasksChangedData Data { get; set; }
}

/// <summary>Ephemeral invalidation signal for a changed factory run.</summary>
/// <remarks>Represents the <c>factory.run_updated</c> event.</remarks>
[Experimental(Diagnostics.Experimental)]
public sealed partial class FactoryRunUpdatedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "factory.run_updated";

    /// <summary>The <c>factory.run_updated</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required FactoryRunUpdatedData Data { get; set; }
}

/// <summary>Ephemeral signal that a factory run attempt began executing.</summary>
/// <remarks>Represents the <c>factory.run_started</c> event.</remarks>
[Experimental(Diagnostics.Experimental)]
public sealed partial class FactoryRunStartedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "factory.run_started";

    /// <summary>The <c>factory.run_started</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required FactoryRunStartedData Data { get; set; }
}

/// <summary>Ephemeral signal that a factory run reached a terminal status.</summary>
/// <remarks>Represents the <c>factory.run_settled</c> event.</remarks>
[Experimental(Diagnostics.Experimental)]
public sealed partial class FactoryRunSettledEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "factory.run_settled";

    /// <summary>The <c>factory.run_settled</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required FactoryRunSettledData Data { get; set; }
}

/// <summary>Payload of `session.skills_loaded` listing resolved skill metadata.</summary>
/// <remarks>Represents the <c>session.skills_loaded</c> event.</remarks>
public sealed partial class SessionSkillsLoadedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.skills_loaded";

    /// <summary>The <c>session.skills_loaded</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionSkillsLoadedData Data { get; set; }
}

/// <summary>Payload of `session.custom_agents_updated` with loaded custom agents plus non-fatal warnings and fatal errors.</summary>
/// <remarks>Represents the <c>session.custom_agents_updated</c> event.</remarks>
public sealed partial class SessionCustomAgentsUpdatedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.custom_agents_updated";

    /// <summary>The <c>session.custom_agents_updated</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionCustomAgentsUpdatedData Data { get; set; }
}

/// <summary>Payload of `session.mcp_servers_loaded` listing MCP server status summaries.</summary>
/// <remarks>Represents the <c>session.mcp_servers_loaded</c> event.</remarks>
public sealed partial class SessionMcpServersLoadedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.mcp_servers_loaded";

    /// <summary>The <c>session.mcp_servers_loaded</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionMcpServersLoadedData Data { get; set; }
}

/// <summary>Payload of `session.mcp_server_status_changed` for one MCP server's status and optional failure error.</summary>
/// <remarks>Represents the <c>session.mcp_server_status_changed</c> event.</remarks>
public sealed partial class SessionMcpServerStatusChangedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.mcp_server_status_changed";

    /// <summary>The <c>session.mcp_server_status_changed</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionMcpServerStatusChangedData Data { get; set; }
}

/// <summary>Payload of `session.mcp_server_removed` identifying an MCP server the graph no longer runs.</summary>
/// <remarks>Represents the <c>session.mcp_server_removed</c> event.</remarks>
public sealed partial class SessionMcpServerRemovedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.mcp_server_removed";

    /// <summary>The <c>session.mcp_server_removed</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionMcpServerRemovedData Data { get; set; }
}

/// <summary>Payload of `session.mcp_server_needs_reconnect` identifying an MCP server whose connection must be re-established.</summary>
/// <remarks>Represents the <c>session.mcp_server_needs_reconnect</c> event.</remarks>
public sealed partial class SessionMcpServerNeedsReconnectEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.mcp_server_needs_reconnect";

    /// <summary>The <c>session.mcp_server_needs_reconnect</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionMcpServerNeedsReconnectData Data { get; set; }
}

/// <summary>Payload identifying the MCP server associated with a list change.</summary>
/// <remarks>Represents the <c>mcp.tools.list_changed</c> event.</remarks>
public sealed partial class McpToolsListChangedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "mcp.tools.list_changed";

    /// <summary>The <c>mcp.tools.list_changed</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required McpToolsListChangedData Data { get; set; }
}

/// <summary>Payload identifying the MCP server associated with a list change.</summary>
/// <remarks>Represents the <c>mcp.resources.list_changed</c> event.</remarks>
public sealed partial class McpResourcesListChangedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "mcp.resources.list_changed";

    /// <summary>The <c>mcp.resources.list_changed</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required McpResourcesListChangedData Data { get; set; }
}

/// <summary>Payload identifying the MCP server associated with a list change.</summary>
/// <remarks>Represents the <c>mcp.prompts.list_changed</c> event.</remarks>
public sealed partial class McpPromptsListChangedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "mcp.prompts.list_changed";

    /// <summary>The <c>mcp.prompts.list_changed</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required McpPromptsListChangedData Data { get; set; }
}

/// <summary>Payload of `session.extensions_loaded` listing discovered extensions and their statuses.</summary>
/// <remarks>Represents the <c>session.extensions_loaded</c> event.</remarks>
public sealed partial class SessionExtensionsLoadedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.extensions_loaded";

    /// <summary>The <c>session.extensions_loaded</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionExtensionsLoadedData Data { get; set; }
}

/// <summary>Payload of `session.canvas.opened` with canvas instance and provider IDs plus optional icon, title, status, URL, and input.</summary>
/// <remarks>Represents the <c>session.canvas.opened</c> event.</remarks>
[Experimental(Diagnostics.Experimental)]
public sealed partial class SessionCanvasOpenedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.canvas.opened";

    /// <summary>The <c>session.canvas.opened</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionCanvasOpenedData Data { get; set; }
}

/// <summary>Payload of `session.canvas.registry_changed` listing the canvas declarations currently available.</summary>
/// <remarks>Represents the <c>session.canvas.registry_changed</c> event.</remarks>
[Experimental(Diagnostics.Experimental)]
public sealed partial class SessionCanvasRegistryChangedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.canvas.registry_changed";

    /// <summary>The <c>session.canvas.registry_changed</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionCanvasRegistryChangedData Data { get; set; }
}

/// <summary>Payload of `session.canvas.closed` with the closed canvas instance ID, provider ID, and canvas ID.</summary>
/// <remarks>Represents the <c>session.canvas.closed</c> event.</remarks>
[Experimental(Diagnostics.Experimental)]
public sealed partial class SessionCanvasClosedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.canvas.closed";

    /// <summary>The <c>session.canvas.closed</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionCanvasClosedData Data { get; set; }
}

/// <summary>Transient signal that an open canvas instance's provider has dropped (for example the extension is reloading mid-session). The host should keep the panel mounted and surface a reconnecting affordance rather than tearing it down; a subsequent `session.canvas.opened` for the same instanceId clears the affordance once the provider reconnects with a fresh url. Ephemeral and never persisted, so it is never replayed on cold resume.</summary>
/// <remarks>Represents the <c>session.canvas.unavailable</c> event.</remarks>
[Experimental(Diagnostics.Experimental)]
public sealed partial class SessionCanvasUnavailableEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.canvas.unavailable";

    /// <summary>The <c>session.canvas.unavailable</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionCanvasUnavailableData Data { get; set; }
}

/// <summary>Durable record that a canvas instance is open, used to restore open canvases on cold session resume. Intentionally omits the transient url and availability.</summary>
/// <remarks>Represents the <c>session.canvas.recorded</c> event.</remarks>
[Experimental(Diagnostics.Experimental)]
public sealed partial class SessionCanvasRecordedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.canvas.recorded";

    /// <summary>The <c>session.canvas.recorded</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionCanvasRecordedData Data { get; set; }
}

/// <summary>Durable record that a canvas instance was closed, superseding a prior instance_recorded during resume replay.</summary>
/// <remarks>Represents the <c>session.canvas.removed</c> event.</remarks>
[Experimental(Diagnostics.Experimental)]
public sealed partial class SessionCanvasRemovedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.canvas.removed";

    /// <summary>The <c>session.canvas.removed</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionCanvasRemovedData Data { get; set; }
}

/// <summary>Payload of `session.extensions.attachments_pushed` with extension-contributed attachments for the next send.</summary>
/// <remarks>Represents the <c>session.extensions.attachments_pushed</c> event.</remarks>
public sealed partial class SessionExtensionsAttachmentsPushedEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "session.extensions.attachments_pushed";

    /// <summary>The <c>session.extensions.attachments_pushed</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required SessionExtensionsAttachmentsPushedData Data { get; set; }
}

/// <summary>MCP App view called a tool on a connected MCP server (SEP-1865).</summary>
/// <remarks>Represents the <c>mcp_app.tool_call_complete</c> event.</remarks>
public sealed partial class McpAppToolCallCompleteEvent : SessionEvent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "mcp_app.tool_call_complete";

    /// <summary>The <c>mcp_app.tool_call_complete</c> event payload.</summary>
    [JsonPropertyName("data")]
    public required McpAppToolCallCompleteData Data { get; set; }
}

/// <summary>Session initialization metadata including context and configuration.</summary>
public sealed partial class SessionStartData
{
    /// <summary>Whether the session was already in use by another client at start time.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("alreadyInUse")]
    public bool? AlreadyInUse { get; set; }

    /// <summary>Auto routing preference selected at session creation time.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("autoTier")]
    public AutoTier? AutoTier { get; set; }

    /// <summary>Working directory and git context at session start.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("context")]
    public WorkingDirectoryContext? Context { get; set; }

    /// <summary>Context tier selected at session creation time for models with tiered context pricing; null when no tier is selected (e.g., non-tiered model).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("contextTier")]
    public ContextTier? ContextTier { get; set; }

    /// <summary>Version string of the Copilot application.</summary>
    [JsonPropertyName("copilotVersion")]
    public required string CopilotVersion { get; set; }

    /// <summary>When set, identifies a parent session whose context this session continues — e.g., a detached headless rem-agent run launched on the parent's interactive shutdown. Telemetry from this session is reported under the parent's session_id.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("detachedFromSpawningParentSessionId")]
    public string? DetachedFromSpawningParentSessionId { get; set; }

    /// <summary>Per-session GitHub MCP override persisted for cold resume.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("githubMcpToolConfig")]
    public GitHubMcpToolConfig? GitHubMcpToolConfig { get; set; }

    /// <summary>Identifier of the software producing the events (e.g., "copilot-agent").</summary>
    [JsonPropertyName("producer")]
    public required string Producer { get; set; }

    /// <summary>Reasoning effort level used for model calls, if applicable (e.g. "none", "low", "medium", "high", "xhigh", "max").</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("reasoningEffort")]
    public string? ReasoningEffort { get; set; }

    /// <summary>Reasoning summary mode used for model calls, if applicable (e.g. "none", "concise", "detailed").</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("reasoningSummary")]
    public ReasoningSummary? ReasoningSummary { get; set; }

    /// <summary>Whether this session supports remote steering via GitHub.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("remoteSteerable")]
    public bool? RemoteSteerable { get; set; }

    /// <summary>Model selected at session creation time, if any.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("selectedModel")]
    public string? SelectedModel { get; set; }

    /// <summary>Unique identifier for the session.</summary>
    [JsonPropertyName("sessionId")]
    public required string SessionId { get; set; }

    /// <summary>Session limits configured at session creation time, if any.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("sessionLimits")]
    public SessionLimitsConfig? SessionLimits { get; set; }

    /// <summary>ISO 8601 timestamp when the session was created.</summary>
    [JsonPropertyName("startTime")]
    public required DateTimeOffset StartTime { get; set; }

    /// <summary>Output verbosity level used for model calls, if applicable (e.g. "low", "medium", "high").</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("verbosity")]
    public Verbosity? Verbosity { get; set; }

    /// <summary>Schema version number for the session event format.</summary>
    [JsonPropertyName("version")]
    public required long Version { get; set; }
}

/// <summary>Session resume metadata including current context and event count.</summary>
public sealed partial class SessionResumeData
{
    /// <summary>Whether the session was already in use by another client at resume time.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("alreadyInUse")]
    public bool? AlreadyInUse { get; set; }

    /// <summary>Auto routing preference active at resume time.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("autoTier")]
    public AutoTier? AutoTier { get; set; }

    /// <summary>Updated working directory and git context at resume time.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("context")]
    public WorkingDirectoryContext? Context { get; set; }

    /// <summary>Context tier currently selected at resume time; null when no tier is active.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("contextTier")]
    public ContextTier? ContextTier { get; set; }

    /// <summary>When true, tool calls and permission requests left in flight by the previous session lifetime remain pending after resume and the agentic loop awaits their results. User sends are queued behind the pending work until all such requests reach a terminal state. When false or omitted, pending work is normally marked as interrupted unless the resume passively joined live work owned by another client; sessionWasActive distinguishes that case.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("continuePendingWork")]
    public bool? ContinuePendingWork { get; set; }

    /// <summary>Total number of persisted events in the session at the time of resume.</summary>
    [JsonPropertyName("eventCount")]
    public required long EventCount { get; set; }

    /// <summary>On-disk byte size of the session's persisted events.jsonl file at resume time; omitted when the file does not exist or cannot be stat'd.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("eventsFileSizeBytes")]
    public long? EventsFileSizeBytes { get; set; }

    /// <summary>Reasoning effort level used for model calls, if applicable (e.g. "none", "low", "medium", "high", "xhigh", "max").</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("reasoningEffort")]
    public string? ReasoningEffort { get; set; }

    /// <summary>Reasoning summary mode used for model calls, if applicable (e.g. "none", "concise", "detailed").</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("reasoningSummary")]
    public ReasoningSummary? ReasoningSummary { get; set; }

    /// <summary>Whether this session supports remote steering via GitHub.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("remoteSteerable")]
    public bool? RemoteSteerable { get; set; }

    /// <summary>ISO 8601 timestamp when the session was resumed.</summary>
    [JsonPropertyName("resumeTime")]
    public required DateTimeOffset ResumeTime { get; set; }

    /// <summary>Model currently selected at resume time.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("selectedModel")]
    public string? SelectedModel { get; set; }

    /// <summary>Session limits currently configured at resume time; null when no limits are active.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("sessionLimits")]
    public SessionLimitsConfig? SessionLimits { get; set; }

    /// <summary>True when this resume passively joined a session that already had live work running in the runtime - an agent turn, a native queue run, a queued resume continuation, or an in-flight send (for example, an extension joining a session another client was actively driving). False (or omitted) when the session had no live work or when the resume explicitly abandoned pending work, including cold resumes and suspended sessions that remain resident in memory.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("sessionWasActive")]
    public bool? SessionWasActive { get; set; }

    /// <summary>Output verbosity level used for model calls, if applicable (e.g. "low", "medium", "high").</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("verbosity")]
    public Verbosity? Verbosity { get; set; }
}

/// <summary>Notifies that the session's remote steering capability has changed.</summary>
public sealed partial class SessionRemoteSteerableChangedData
{
    /// <summary>Whether this session now supports remote steering via GitHub.</summary>
    [JsonPropertyName("remoteSteerable")]
    public required bool RemoteSteerable { get; set; }
}

/// <summary>Error details for timeline display including message and optional diagnostic information.</summary>
public sealed partial class SessionErrorData
{
    /// <summary>Only set on `errorType: "rate_limit"`. When `true`, the runtime will follow this error with an `auto_mode_switch.requested` event (or silently switch if `continueOnAutoMode` is enabled). UI clients can use this flag to suppress duplicate rendering of the rate-limit error when they show their own auto-mode-switch prompt.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("eligibleForAutoSwitch")]
    public bool? EligibleForAutoSwitch { get; set; }

    /// <summary>Fine-grained error code from the upstream provider, when available. For `errorType: "rate_limit"`, this is one of the `RateLimitErrorCode` values (e.g., `"user_weekly_rate_limited"`, `"user_global_rate_limited"`, `"rate_limited"`, `"user_model_rate_limited"`, `"integration_rate_limited"`). For `errorType: "quota"`, this is the CAPI quota error code (e.g., `"quota_exceeded"`, `"session_quota_exceeded"`, `"billing_not_configured"`).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("errorCode")]
    public string? ErrorCode { get; set; }

    /// <summary>Category of error (e.g., "authentication", "authorization", "quota", "rate_limit", "context_limit", "query").</summary>
    [JsonPropertyName("errorType")]
    public required string ErrorType { get; set; }

    /// <summary>Human-readable error message.</summary>
    [JsonPropertyName("message")]
    public required string Message { get; set; }

    /// <summary>GitHub request tracing ID (x-github-request-id header) for correlating with server-side logs.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("providerCallId")]
    public string? ProviderCallId { get; set; }

    /// <summary>What the user must do to recover, when the runtime knows of an action. The `message` never names a client affordance, so a client that offers one — a slash command, a settings pane, a link — renders it from this value.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("remediation")]
    public RemediationAction? Remediation { get; set; }

    /// <summary>Copilot service request ID (x-copilot-service-request-id header) for CAPI log correlation.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("serviceRequestId")]
    public string? ServiceRequestId { get; set; }

    /// <summary>Error stack trace, when available.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("stack")]
    public string? Stack { get; set; }

    /// <summary>HTTP status code from the upstream request, if applicable.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("statusCode")]
    public int? StatusCode { get; set; }

    /// <summary>Optional URL associated with this error that the user can open in a browser.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("url")]
    public string? Url { get; set; }
}

/// <summary>Payload indicating the session is idle with no background agents or attached shell commands in flight.</summary>
public sealed partial class SessionIdleData
{
    /// <summary>True when the preceding agentic loop was cancelled via abort signal.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("aborted")]
    public bool? Aborted { get; set; }

    /// <summary>The session mode the agent was operating in when it went idle, when the mode is known. Lets turn-scoped consumers distinguish an autopilot continuation boundary (where the agent keeps working after this idle) from a genuine turn completion.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("mode")]
    public SessionMode? Mode { get; set; }
}

/// <summary>Session title change payload containing the new display title.</summary>
public sealed partial class SessionTitleChangedData
{
    /// <summary>The new display title for the session.</summary>
    [JsonPropertyName("title")]
    public required string Title { get; set; }
}

/// <summary>Scheduled prompt registered via /every or /after.</summary>
public sealed partial class SessionScheduleCreatedData
{
    /// <summary>Absolute fire time (epoch milliseconds) for a one-shot calendar schedule.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("at")]
    public long? At { get; set; }

    /// <summary>5-field cron expression for a recurring calendar schedule, evaluated in `tz`.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("cron")]
    public string? Cron { get; set; }

    /// <summary>Optional user-facing label shown in the timeline instead of the actual prompt (e.g. `/skill-name args` when the prompt is a skill invocation expansion).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("displayPrompt")]
    public string? DisplayPrompt { get; set; }

    /// <summary>Sequential id assigned to the scheduled prompt within the session.</summary>
    [JsonPropertyName("id")]
    public required long Id { get; set; }

    /// <summary>Interval between ticks in milliseconds (relative-interval schedules).</summary>
    [JsonConverter(typeof(MillisecondsTimeSpanConverter))]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("intervalMs")]
    public TimeSpan? Interval { get; set; }

    /// <summary>Who created the schedule (`user` or `model`). Persisted so a resumed session keeps gating non-user schedules from firing skills that opted out of model invocation. Absent on entries created before this field existed; a missing origin fails closed (treated the same as a non-user origin), so such a schedule may not resolve a `disable-model-invocation` skill.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("origin")]
    public ScheduleOrigin? Origin { get; set; }

    /// <summary>Prompt text that gets enqueued on every tick.</summary>
    [JsonPropertyName("prompt")]
    public required string Prompt { get; set; }

    /// <summary>Whether the schedule re-arms after each tick (`/every`) or fires once (`/after`).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("recurring")]
    public bool? Recurring { get; set; }

    /// <summary>True for a self-paced (`dynamic`) schedule: no fixed cadence; the model arms each next run via the `manage_schedule` `wakeup` action. `nextRunAt` is model-controlled rather than auto-computed.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("selfPaced")]
    public bool? SelfPaced { get; set; }

    /// <summary>IANA timezone the `cron` expression is evaluated in.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("tz")]
    public string? Tz { get; set; }
}

/// <summary>Scheduled prompt cancelled from the schedule manager dialog.</summary>
public sealed partial class SessionScheduleCancelledData
{
    /// <summary>Id of the scheduled prompt that was cancelled.</summary>
    [JsonPropertyName("id")]
    public required long Id { get; set; }
}

/// <summary>Self-paced schedule re-armed for its next run.</summary>
public sealed partial class SessionScheduleRearmedData
{
    /// <summary>Id of the self-paced schedule that was re-armed.</summary>
    [JsonPropertyName("id")]
    public required long Id { get; set; }

    /// <summary>Absolute time (epoch milliseconds) the model armed the next run to fire.</summary>
    [JsonPropertyName("nextRunAt")]
    public required long NextRunAt { get; set; }
}

/// <summary>Autopilot objective state file operation details indicating what changed.</summary>
public sealed partial class SessionAutopilotObjectiveChangedData
{
    /// <summary>Current autopilot objective id, if one exists.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("id")]
    public long? Id { get; set; }

    /// <summary>The type of operation performed on the autopilot objective state file.</summary>
    [JsonPropertyName("operation")]
    public required AutopilotObjectiveChangedOperation Operation { get; set; }

    /// <summary>Current autopilot objective status, if one exists.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("status")]
    public AutopilotObjectiveChangedStatus? Status { get; set; }
}

/// <summary>Informational message for timeline display with categorization.</summary>
public sealed partial class SessionInfoData
{
    /// <summary>Category of informational message (e.g., "notification", "timing", "context_window", "mcp", "snapshot", "configuration", "authentication", "model").</summary>
    [JsonPropertyName("infoType")]
    public required string InfoType { get; set; }

    /// <summary>Human-readable informational message for display in the timeline.</summary>
    [JsonPropertyName("message")]
    public required string Message { get; set; }

    /// <summary>Optional actionable tip displayed with this message.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("tip")]
    public string? Tip { get; set; }

    /// <summary>Optional URL associated with this message that the user can open in a browser.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("url")]
    public string? Url { get; set; }
}

/// <summary>Warning message for timeline display with categorization.</summary>
public sealed partial class SessionWarningData
{
    /// <summary>Human-readable warning message for display in the timeline.</summary>
    [JsonPropertyName("message")]
    public required string Message { get; set; }

    /// <summary>What the user must do to recover, when the runtime knows of an action. The `message` never names a client affordance, so a client that offers one — a slash command, a settings pane, a link — renders it from this value.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("remediation")]
    public RemediationAction? Remediation { get; set; }

    /// <summary>Optional URL associated with this warning that the user can open in a browser.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("url")]
    public string? Url { get; set; }

    /// <summary>Category of warning (e.g., "subscription", "policy", "mcp").</summary>
    [JsonPropertyName("warningType")]
    public required string WarningType { get; set; }
}

/// <summary>Model change details including previous and new model identifiers.</summary>
public sealed partial class SessionModelChangeData
{
    /// <summary>Committed Auto preference after the model configuration change, when applicable.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("autoTier")]
    public AutoTier? AutoTier { get; set; }

    /// <summary>Reason the change happened, when not user-initiated. `"rate_limit_auto_switch"` for changes triggered by the auto-mode-switch rate-limit recovery path, or `"refusal_fallback"` when the active model declined a request (content refusal) and the runtime switched to the configured refusal-fallback model. UI clients can use this to render contextual copy.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("cause")]
    public string? Cause { get; set; }

    /// <summary>Context tier after the model change; null explicitly clears a previously selected tier.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("contextTier")]
    public ContextTier? ContextTier { get; set; }

    /// <summary>Newly selected model identifier.</summary>
    [JsonPropertyName("newModel")]
    public required string NewModel { get; set; }

    /// <summary>Previously committed Auto preference, when one was explicitly selected.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("previousAutoTier")]
    public AutoTier? PreviousAutoTier { get; set; }

    /// <summary>Model that was previously selected, if any.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("previousModel")]
    public string? PreviousModel { get; set; }

    /// <summary>Reasoning effort level before the model change, if applicable.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("previousReasoningEffort")]
    public string? PreviousReasoningEffort { get; set; }

    /// <summary>Reasoning summary mode before the model change, if applicable.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("previousReasoningSummary")]
    public ReasoningSummary? PreviousReasoningSummary { get; set; }

    /// <summary>Output verbosity level before the model change, if applicable.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("previousVerbosity")]
    public Verbosity? PreviousVerbosity { get; set; }

    /// <summary>Reasoning effort level after the model change, if applicable.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("reasoningEffort")]
    public string? ReasoningEffort { get; set; }

    /// <summary>Reasoning summary mode after the model change, if applicable.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("reasoningSummary")]
    public ReasoningSummary? ReasoningSummary { get; set; }

    /// <summary>Origin of the effective model change, when known.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("source")]
    public ModelChangeSource? Source { get; set; }

    /// <summary>Output verbosity level after the model change, if applicable.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("verbosity")]
    public Verbosity? Verbosity { get; set; }
}

/// <summary>A transient Auto preference failure emitted when the runtime cannot mint or accept a usable model and token pair. The previously effective preference remains active, so SDK clients can surface a non-blocking failure without changing their committed-tier state. This event is ephemeral and is not persisted or replayed on resume.</summary>
public sealed partial class SessionAutoTierSwitchFailedData
{
    /// <summary>Auto preference that remains effective after the failed request.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("effectiveAutoTier")]
    public AutoTier? EffectiveAutoTier { get; set; }

    /// <summary>Low-cardinality failure outcome reported by Auto resolution.</summary>
    [JsonPropertyName("reason")]
    public required AutoTierSwitchFailureReason Reason { get; set; }

    /// <summary>Auto preference that failed to activate, or null when returning to provider-default routing failed.</summary>
    [JsonPropertyName("requestedAutoTier")]
    public AutoTier? RequestedAutoTier { get; set; }
}

/// <summary>Agent mode change details including previous and new modes.</summary>
public sealed partial class SessionModeChangedData
{
    /// <summary>The session mode the agent is operating in.</summary>
    [JsonPropertyName("newMode")]
    public required SessionMode NewMode { get; set; }

    /// <summary>The session mode the agent is operating in.</summary>
    [JsonPropertyName("previousMode")]
    public required SessionMode PreviousMode { get; set; }
}

/// <summary>Records that a mode transition notice reached the model so cache-stable mode tools can remain offered across resume.</summary>
public sealed partial class SessionModeNoticeDeliveredData
{
    /// <summary>Model-visible transition notice persisted for a mid-turn delivery.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("content")]
    public string? Content { get; set; }

    /// <summary>Mode established by the delivered transition notice.</summary>
    [JsonPropertyName("mode")]
    public required SessionMode Mode { get; set; }
}

/// <summary>Session limits update details. Null clears the limits.</summary>
public sealed partial class SessionSessionLimitsChangedData
{
    /// <summary>Current session limits, or null when no limits are active.</summary>
    [JsonPropertyName("sessionLimits")]
    public SessionLimitsConfig? SessionLimits { get; set; }
}

/// <summary>Permission-mode transition details.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed partial class SessionPermissionsChangedData
{
    /// <summary>Explicit LLM judge model override used by assisted mode; omitted when the provider default applies.</summary>
    [Experimental(Diagnostics.Experimental)]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("assistedApprovalModel")]
    public string? AssistedApprovalModel { get; set; }

    /// <summary>Permission mode after the change.</summary>
    [Experimental(Diagnostics.Experimental)]
    [JsonPropertyName("mode")]
    public required PermissionMode Mode { get; set; }

    /// <summary>Permission mode before the change.</summary>
    [Experimental(Diagnostics.Experimental)]
    [JsonPropertyName("previousMode")]
    public required PermissionMode PreviousMode { get; set; }
}

/// <summary>Plan file operation details indicating what changed.</summary>
public sealed partial class SessionPlanChangedData
{
    /// <summary>The type of operation performed on the plan file.</summary>
    [JsonPropertyName("operation")]
    public required PlanChangedOperation Operation { get; set; }
}

/// <summary>Signal-only event: the agent's todos or todo_deps table was written to. No payload — clients should call session.plan.readSqlTodosWithDependencies() to fetch the current state. Events arrive in order; clients can debounce on arrival if needed.</summary>
public sealed partial class SessionTodosChangedData
{
}

/// <summary>Workspace file change details including path and operation type.</summary>
public sealed partial class SessionWorkspaceFileChangedData
{
    /// <summary>Whether the file was newly created or updated.</summary>
    [JsonPropertyName("operation")]
    public required WorkspaceFileChangedOperation Operation { get; set; }

    /// <summary>Relative path within the session workspace files directory.</summary>
    [JsonPropertyName("path")]
    public required string Path { get; set; }
}

/// <summary>Session handoff metadata including source, context, and repository information.</summary>
public sealed partial class SessionHandoffData
{
    /// <summary>Additional context information for the handoff.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("context")]
    public string? Context { get; set; }

    /// <summary>ISO 8601 timestamp when the handoff occurred.</summary>
    [JsonPropertyName("handoffTime")]
    public required DateTimeOffset HandoffTime { get; set; }

    /// <summary>GitHub host URL for the source session (e.g., https://github.com or https://tenant.ghe.com).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("host")]
    public string? Host { get; set; }

    /// <summary>Session ID of the remote session being handed off.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("remoteSessionId")]
    public string? RemoteSessionId { get; set; }

    /// <summary>Repository context for the handed-off session.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("repository")]
    public HandoffRepository? Repository { get; set; }

    /// <summary>Origin type of the session being handed off.</summary>
    [JsonPropertyName("sourceType")]
    public required HandoffSourceType SourceType { get; set; }

    /// <summary>Summary of the work done in the source session.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("summary")]
    public string? Summary { get; set; }
}

/// <summary>Conversation truncation statistics including token counts and removed content metrics.</summary>
public sealed partial class SessionTruncationData
{
    /// <summary>Number of messages removed by truncation.</summary>
    [JsonPropertyName("messagesRemovedDuringTruncation")]
    public required long MessagesRemovedDuringTruncation { get; set; }

    /// <summary>Identifier of the component that performed truncation (e.g., "BasicTruncator").</summary>
    [JsonPropertyName("performedBy")]
    public required string PerformedBy { get; set; }

    /// <summary>Number of conversation messages after truncation.</summary>
    [JsonPropertyName("postTruncationMessagesLength")]
    public required long PostTruncationMessagesLength { get; set; }

    /// <summary>Total tokens in conversation messages after truncation.</summary>
    [JsonPropertyName("postTruncationTokensInMessages")]
    public required long PostTruncationTokensInMessages { get; set; }

    /// <summary>Number of conversation messages before truncation.</summary>
    [JsonPropertyName("preTruncationMessagesLength")]
    public required long PreTruncationMessagesLength { get; set; }

    /// <summary>Total tokens in conversation messages before truncation.</summary>
    [JsonPropertyName("preTruncationTokensInMessages")]
    public required long PreTruncationTokensInMessages { get; set; }

    /// <summary>Maximum token count for the model's context window.</summary>
    [JsonPropertyName("tokenLimit")]
    public required long TokenLimit { get; set; }

    /// <summary>Number of tokens removed by truncation.</summary>
    [JsonPropertyName("tokensRemovedDuringTruncation")]
    public required long TokensRemovedDuringTruncation { get; set; }
}

/// <summary>Session rewind details including target event and count of removed events.</summary>
public sealed partial class SessionSnapshotRewindData
{
    /// <summary>Number of events that were removed by the rewind.</summary>
    [JsonPropertyName("eventsRemoved")]
    public required long EventsRemoved { get; set; }

    /// <summary>Event ID that was rewound to; this event and all after it were removed.</summary>
    [JsonPropertyName("upToEventId")]
    public required string UpToEventId { get; set; }
}

/// <summary>Session termination metrics including usage statistics, code changes, and shutdown reason.</summary>
public sealed partial class SessionShutdownData
{
    /// <summary>Per-agent usage breakdown, keyed by agent instance identifier. The main conversation uses the stable key `main`.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("agentMetrics")]
    public IDictionary<string, ShutdownAgentMetric>? AgentMetrics { get; set; }

    /// <summary>Aggregate code change metrics for the session.</summary>
    [JsonPropertyName("codeChanges")]
    public required ShutdownCodeChanges CodeChanges { get; set; }

    /// <summary>Non-system message token count at shutdown.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("conversationTokens")]
    public long? ConversationTokens { get; set; }

    /// <summary>Model that was selected at the time of shutdown.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("currentModel")]
    public string? CurrentModel { get; set; }

    /// <summary>Total tokens in context window at shutdown.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("currentTokens")]
    public long? CurrentTokens { get; set; }

    /// <summary>Error description when shutdownType is "error".</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("errorReason")]
    public string? ErrorReason { get; set; }

    /// <summary>On-disk byte size of the session's persisted events.jsonl file at shutdown time; omitted when the file does not exist or cannot be stat'd.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("eventsFileSizeBytes")]
    public long? EventsFileSizeBytes { get; set; }

    /// <summary>Per-model usage breakdown, keyed by model identifier.</summary>
    [JsonPropertyName("modelMetrics")]
    public required IDictionary<string, ShutdownModelMetric> ModelMetrics { get; set; }

    /// <summary>Unix timestamp (milliseconds) when the session started.</summary>
    [JsonPropertyName("sessionStartTime")]
    public required long SessionStartTime { get; set; }

    /// <summary>Whether the session ended normally ("routine") or due to a crash/fatal error ("error").</summary>
    [JsonPropertyName("shutdownType")]
    public required ShutdownType ShutdownType { get; set; }

    /// <summary>System message token count at shutdown.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("systemTokens")]
    public long? SystemTokens { get; set; }

    /// <summary>Session-wide per-token-type accumulated token counts.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("tokenDetails")]
    public IDictionary<string, ShutdownTokenDetail>? TokenDetails { get; set; }

    /// <summary>Tool definitions token count at shutdown.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("toolDefinitionsTokens")]
    public long? ToolDefinitionsTokens { get; set; }

    /// <summary>Cumulative time spent in API calls during the session, in milliseconds.</summary>
    [JsonConverter(typeof(MillisecondsTimeSpanConverter))]
    [JsonPropertyName("totalApiDurationMs")]
    public required TimeSpan TotalApiDuration { get; set; }

    /// <summary>Session-wide accumulated nano-AI units cost.</summary>
    [Experimental(Diagnostics.Experimental)]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("totalNanoAiu")]
    public double? TotalNanoAiu { get; set; }

    /// <summary>Total number of premium API requests used during the session.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonInclude]
    [JsonPropertyName("totalPremiumRequests")]
    internal double? TotalPremiumRequests { get; set; }
}

/// <summary>Durable session usage checkpoint for reconstructing aggregate accounting on resume.</summary>
public sealed partial class SessionUsageCheckpointData
{
    /// <summary>Internal per-model prompt-cache state used to restore expiration tracking on resume.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonInclude]
    [JsonPropertyName("modelCacheState")]
    internal UsageCheckpointModelCacheState[]? ModelCacheState { get; set; }

    /// <summary>Internal per-conversation prompt-cache-break detector baselines restored on resume.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonInclude]
    [JsonPropertyName("promptCacheBreakState")]
    internal JsonElement[]? PromptCacheBreakState { get; set; }

    /// <summary>Session-wide accumulated nano-AI units cost at checkpoint time.</summary>
    [JsonPropertyName("totalNanoAiu")]
    public required double TotalNanoAiu { get; set; }

    /// <summary>Total number of premium API requests used at checkpoint time.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonInclude]
    [JsonPropertyName("totalPremiumRequests")]
    internal double? TotalPremiumRequests { get; set; }
}

/// <summary>Working directory and git context at session start.</summary>
public sealed partial class SessionContextChangedData
{
    /// <summary>Base commit of current git branch at session start time.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("baseCommit")]
    public string? BaseCommit { get; set; }

    /// <summary>Current git branch name.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("branch")]
    public string? Branch { get; set; }

    /// <summary>Current working directory path.</summary>
    [JsonPropertyName("cwd")]
    public required string Cwd { get; set; }

    /// <summary>Root directory of the git repository, resolved via git rev-parse.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("gitRoot")]
    public string? GitRoot { get; set; }

    /// <summary>Head commit of current git branch at session start time.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("headCommit")]
    public string? HeadCommit { get; set; }

    /// <summary>Hosting platform type of the repository (github or ado).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("hostType")]
    public WorkingDirectoryContextHostType? HostType { get; set; }

    /// <summary>Set on the immediate preliminary event of a working-directory change, before the git context is resolved. A settled follow-up event (enriched with git context, or cwd-only for a non-repository) is always emitted afterward, so observers may defer to it. Absent on standalone/final events (e.g. relay context changes).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("pendingGitContext")]
    public bool? PendingGitContext { get; set; }

    /// <summary>Repository identifier derived from the git remote URL ("owner/name" for GitHub, "org/project/repo" for Azure DevOps).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("repository")]
    public string? Repository { get; set; }

    /// <summary>Raw host string from the git remote URL (e.g. "github.com", "mycompany.ghe.com", "dev.azure.com").</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("repositoryHost")]
    public string? RepositoryHost { get; set; }
}

/// <summary>Current context window usage statistics including token and message counts.</summary>
public sealed partial class SessionUsageInfoData
{
    /// <summary>Token count from non-system messages (user, assistant, tool).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("conversationTokens")]
    public long? ConversationTokens { get; set; }

    /// <summary>Current number of tokens in the context window.</summary>
    [JsonPropertyName("currentTokens")]
    public required long CurrentTokens { get; set; }

    /// <summary>Whether this is the first usage_info event emitted in this session.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("isInitial")]
    public bool? IsInitial { get; set; }

    /// <summary>Current number of messages in the conversation.</summary>
    [JsonPropertyName("messagesLength")]
    public required long MessagesLength { get; set; }

    /// <summary>Token count from system message(s).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("systemTokens")]
    public long? SystemTokens { get; set; }

    /// <summary>Maximum token count for the model's context window.</summary>
    [JsonPropertyName("tokenLimit")]
    public required long TokenLimit { get; set; }

    /// <summary>Token count from tool definitions.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("toolDefinitionsTokens")]
    public long? ToolDefinitionsTokens { get; set; }
}

/// <summary>Context-cleared details emitted when the host clears the conversation (the session.history.clearContext RPC / Session.clearContextMessages).</summary>
public sealed partial class SessionContextClearedData
{
    /// <summary>Optional initial message set after clearing.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("initialMessage")]
    public string? InitialMessage { get; set; }

    /// <summary>Number of conversation messages that were cleared.</summary>
    [JsonPropertyName("messagesCleared")]
    public required long MessagesCleared { get; set; }
}

/// <summary>Context window breakdown at the start of LLM-powered conversation compaction.</summary>
public sealed partial class SessionCompactionStartData
{
    /// <summary>Token count from non-system messages (user, assistant, tool) at compaction start.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("conversationTokens")]
    public long? ConversationTokens { get; set; }

    /// <summary>Total context tokens (system + conversation + tool definitions) at compaction start, when known.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("currentTokens")]
    public long? CurrentTokens { get; set; }

    /// <summary>Model identifier used for compaction, when known.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("model")]
    public string? Model { get; set; }

    /// <summary>Token count from system message(s) at compaction start.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("systemTokens")]
    public long? SystemTokens { get; set; }

    /// <summary>Model context window token limit the compaction is targeting, when known.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("tokenLimit")]
    public long? TokenLimit { get; set; }

    /// <summary>Token count from tool definitions at compaction start.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("toolDefinitionsTokens")]
    public long? ToolDefinitionsTokens { get; set; }

    /// <summary>What initiated this compaction, when known.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("trigger")]
    public CompactionTrigger? Trigger { get; set; }
}

/// <summary>Conversation compaction results including success status, metrics, and optional error details.</summary>
public sealed partial class SessionCompactionCompleteData
{
    /// <summary>Canonical model identifier used for model-specific behavior when replaying compaction.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("behaviorModelId")]
    public string? BehaviorModelId { get; set; }

    /// <summary>Checkpoint snapshot number created for recovery.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("checkpointNumber")]
    public long? CheckpointNumber { get; set; }

    /// <summary>File path where the checkpoint was stored.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("checkpointPath")]
    public string? CheckpointPath { get; set; }

    /// <summary>Token usage breakdown for the compaction LLM call (aligned with assistant.usage format).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("compactionTokensUsed")]
    public CompactionCompleteCompactionTokensUsed? CompactionTokensUsed { get; set; }

    /// <summary>Token count from non-system messages (user, assistant, tool) after compaction.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("conversationTokens")]
    public long? ConversationTokens { get; set; }

    /// <summary>User-supplied focus instructions provided to a manual `/compact` invocation. Omitted for automatic compaction and for manual compaction with no focus text.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("customInstructions")]
    public string? CustomInstructions { get; set; }

    /// <summary>Error message if compaction failed.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("error")]
    public string? Error { get; set; }

    /// <summary>Number of messages removed during compaction.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("messagesRemoved")]
    public long? MessagesRemoved { get; set; }

    /// <summary>Total tokens in conversation after compaction.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("postCompactionTokens")]
    public long? PostCompactionTokens { get; set; }

    /// <summary>Number of messages before compaction.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("preCompactionMessagesLength")]
    public long? PreCompactionMessagesLength { get; set; }

    /// <summary>Total tokens in conversation before compaction.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("preCompactionTokens")]
    public long? PreCompactionTokens { get; set; }

    /// <summary>GitHub request tracing ID (x-github-request-id header) for the compaction LLM call.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("requestId")]
    public string? RequestId { get; set; }

    /// <summary>Copilot service request ID (x-copilot-service-request-id header) for the compaction LLM call.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("serviceRequestId")]
    public string? ServiceRequestId { get; set; }

    /// <summary>For failed compaction only: the HTTP status code of the compaction LLM call failure, when it carried one. Absent for successful compaction and for failures without an HTTP status (e.g. an empty model response or a transport error).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("statusCode")]
    public long? StatusCode { get; set; }

    /// <summary>Whether compaction completed successfully.</summary>
    [JsonPropertyName("success")]
    public required bool Success { get; set; }

    /// <summary>LLM-generated summary of the compacted conversation history.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("summaryContent")]
    public string? SummaryContent { get; set; }

    /// <summary>Token count from system message(s) after compaction.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("systemTokens")]
    public long? SystemTokens { get; set; }

    /// <summary>Model context window token limit the compaction was targeting, when known.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("tokenLimit")]
    public long? TokenLimit { get; set; }

    /// <summary>Number of tokens removed during compaction.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("tokensRemoved")]
    public long? TokensRemoved { get; set; }

    /// <summary>Token count from tool definitions after compaction.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("toolDefinitionsTokens")]
    public long? ToolDefinitionsTokens { get; set; }

    /// <summary>What initiated this compaction, when known.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("trigger")]
    public CompactionTrigger? Trigger { get; set; }
}

/// <summary>Task completion notification with summary from the agent.</summary>
public sealed partial class SessionTaskCompleteData
{
    /// <summary>Active autopilot objective ID evaluated by the completion reviewer.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("objectiveId")]
    public long? ObjectiveId { get; set; }

    /// <summary>Semantic completion decision. Absent on legacy events and invalid tool calls.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("outcome")]
    public TaskCompletionOutcome? Outcome { get; set; }

    /// <summary>Label-safe runtime rationale for the completion decision (e.g. a cancellation or pause/resume downgrade), when one applies. Reviewer-authored rationale is intentionally omitted here because this event has no IFC label channel; the reviewer's findings remain available through its own labeled sub-agent events.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("reason")]
    public string? Reason { get; set; }

    /// <summary>Whether the task was accepted as complete. False when validation failed or completion was rejected or blocked by the reviewer.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("success")]
    public bool? Success { get; set; }

    /// <summary>Summary of the completed task, provided by the agent.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("summary")]
    public string? Summary { get; set; }
}

/// <summary>Behavior-neutral record of structured runtime facts present when an agent completion decision is accepted.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed partial class SessionCompletionReceiptData
{
    /// <summary>One-based accepted completion receipt ordinal in the durable session history.</summary>
    [JsonPropertyName("attempt")]
    public required long Attempt { get; set; }

    /// <summary>Inclusive durable event range summarized by this receipt.</summary>
    [JsonPropertyName("eventRange")]
    public required CompletionReceiptEventRange EventRange { get; set; }

    /// <summary>Number of failed structured tool completions in the covered range.</summary>
    [JsonPropertyName("failedToolCount")]
    public required long FailedToolCount { get; set; }

    /// <summary>Final structured tool completion in the covered range, when one exists.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("finalTool")]
    public CompletionReceiptFinalTool? FinalTool { get; set; }

    /// <summary>Version of the completion receipt payload.</summary>
    [JsonPropertyName("schemaVersion")]
    public required long SchemaVersion { get; set; }

    /// <summary>Identifier of the assistant turn-end event that supplied the accepted completion boundary. This is the receipt's idempotency key, and always equals eventRange.endEventId.</summary>
    [JsonPropertyName("sourceEventId")]
    public required string SourceEventId { get; set; }

    /// <summary>Runtime reason the completion decision was accepted.</summary>
    [JsonPropertyName("stopReason")]
    public required CompletionReceiptStopReason StopReason { get; set; }

    /// <summary>Number of successful structured tool completions in the covered range.</summary>
    [JsonPropertyName("successfulToolCount")]
    public required long SuccessfulToolCount { get; set; }
}

/// <summary>Experimental transient signal that HydraFusion routing has started for an eligible turn.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed partial class SessionFusionRouteStartedData
{
    /// <summary>Identifier for this routing attempt before a durable Fusion turn exists.</summary>
    [JsonPropertyName("attemptId")]
    public required string AttemptId { get; set; }

    /// <summary>HydraFusion routing policy requested for the turn.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("policy")]
    public string? Policy { get; set; }

    /// <summary>Synthetic HydraFusion model selected for the session.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("syntheticModel")]
    public string? SyntheticModel { get; set; }

    /// <summary>Kind of turn being routed.</summary>
    [JsonPropertyName("turnKind")]
    public required FusionTurnKind TurnKind { get; set; }
}

/// <summary>Experimental durable HydraFusion routing failure and the deterministic concrete fallback selected for the turn.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed partial class SessionFusionRouteFailedData
{
    /// <summary>Identifier of the routing attempt that failed.</summary>
    [JsonPropertyName("attemptId")]
    public required string AttemptId { get; set; }

    /// <summary>Provider or validation error detail, when available.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("errorMessage")]
    public string? ErrorMessage { get; set; }

    /// <summary>Concrete model selected as the deterministic fallback.</summary>
    [JsonPropertyName("fallbackModel")]
    public required string FallbackModel { get; set; }

    /// <summary>HydraFusion routing policy requested for the turn.</summary>
    [JsonPropertyName("policy")]
    public required string Policy { get; set; }

    /// <summary>Stable machine-readable reason for the routing failure.</summary>
    [JsonPropertyName("reason")]
    public required string Reason { get; set; }

    /// <summary>Elapsed routing time in milliseconds before the failure.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("routingLatencyMs")]
    public double? RoutingLatencyMs { get; set; }

    /// <summary>Synthetic HydraFusion model selected for the session.</summary>
    [JsonPropertyName("syntheticModel")]
    public required string SyntheticModel { get; set; }
}

/// <summary>Experimental durable validated HydraFusion route and turn policy.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed partial class SessionFusionResolvedData
{
    /// <summary>Version of the validated HydraFusion event contract.</summary>
    [JsonPropertyName("contractVersion")]
    public required long ContractVersion { get; set; }

    /// <summary>Concrete model used when the planned primary model cannot execute.</summary>
    [JsonPropertyName("fallbackModel")]
    public required string FallbackModel { get; set; }

    /// <summary>Router recommendation controlling reuse or rerouting on later turns.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("followUp")]
    public FusionFollowUpRecommendation? FollowUp { get; set; }

    /// <summary>Concrete model recommended for eligible follow-up turns.</summary>
    [JsonPropertyName("followUpModel")]
    public required string FollowUpModel { get; set; }

    /// <summary>Stable identifier for the resolved HydraFusion turn.</summary>
    [JsonPropertyName("fusionId")]
    public required string FusionId { get; set; }

    /// <summary>Version of the executable model universe used for selection.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("modelUniverseVersion")]
    public string? ModelUniverseVersion { get; set; }

    /// <summary>Validated orchestration pattern selected for the turn.</summary>
    [JsonPropertyName("pattern")]
    public required FusionPattern Pattern { get; set; }

    /// <summary>Presentation-neutral phase plan for clients that render workflow progress.</summary>
    [Experimental(Diagnostics.Experimental)]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("phasePlan")]
    public FusionPhasePlanStep[]? PhasePlan { get; set; }

    /// <summary>Version of the validated execution-plan format.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("planVersion")]
    public string? PlanVersion { get; set; }

    /// <summary>HydraFusion routing policy used to resolve the plan.</summary>
    [JsonPropertyName("policy")]
    public required string Policy { get; set; }

    /// <summary>Version of the local routing policy.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("policyVersion")]
    public string? PolicyVersion { get; set; }

    /// <summary>Concrete model selected for the primary solver phase.</summary>
    [JsonPropertyName("primaryModel")]
    public required string PrimaryModel { get; set; }

    /// <summary>Router implementation that supplied the plan.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("routeSource")]
    public string? RouteSource { get; set; }

    /// <summary>Elapsed time in milliseconds required to resolve and validate the route.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("routingLatencyMs")]
    public double? RoutingLatencyMs { get; set; }

    /// <summary>Identifier of the local policy rule that matched.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("ruleId")]
    public string? RuleId { get; set; }

    /// <summary>Zero-based index of the local policy rule that matched.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("ruleIndex")]
    public long? RuleIndex { get; set; }

    /// <summary>Human-readable name of the local policy rule that matched.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("ruleName")]
    public string? RuleName { get; set; }

    /// <summary>Validated capability scores used to select the route.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("scores")]
    public FusionScores? Scores { get; set; }

    /// <summary>Concrete model selected for the review or judge phase, when required.</summary>
    [JsonPropertyName("secondaryModel")]
    public string? SecondaryModel { get; set; }

    /// <summary>Synthetic HydraFusion model selected for the session.</summary>
    [JsonPropertyName("syntheticModel")]
    public required string SyntheticModel { get; set; }

    /// <summary>Identifier of the session turn associated with the route.</summary>
    [JsonPropertyName("turnId")]
    public required string TurnId { get; set; }
}

/// <summary>Experimental durable aggregate outcome of a HydraFusion turn.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed partial class SessionFusionCompletedData
{
    /// <summary>Total cached input tokens reported across all phases.</summary>
    [JsonPropertyName("cachedTokens")]
    public required long CachedTokens { get; set; }

    /// <summary>Total tokens written to prompt cache across all phases.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("cacheWriteTokens")]
    public long? CacheWriteTokens { get; set; }

    /// <summary>Idempotency identifier for the authoritative final commit.</summary>
    [JsonPropertyName("commitId")]
    public required string CommitId { get; set; }

    /// <summary>Reason the turn used a degraded route, when applicable.</summary>
    [JsonPropertyName("degradedReason")]
    public string? DegradedReason { get; set; }

    /// <summary>Total elapsed execution time for the HydraFusion turn in milliseconds.</summary>
    [JsonPropertyName("durationMs")]
    public required double DurationMs { get; set; }

    /// <summary>Concrete model that supplied the authoritative final content.</summary>
    [JsonPropertyName("finalSourceModel")]
    public string? FinalSourceModel { get; set; }

    /// <summary>Phase whose output supplied the authoritative final content.</summary>
    [JsonPropertyName("finalSourcePhaseId")]
    public string? FinalSourcePhaseId { get; set; }

    /// <summary>Concrete model recommended for eligible follow-up turns.</summary>
    [JsonPropertyName("followUpModel")]
    public required string FollowUpModel { get; set; }

    /// <summary>Stable identifier for the completed HydraFusion turn.</summary>
    [JsonPropertyName("fusionId")]
    public required string FusionId { get; set; }

    /// <summary>Total input tokens consumed across all phases.</summary>
    [JsonPropertyName("inputTokens")]
    public required long InputTokens { get; set; }

    /// <summary>Stable aggregate outcome of the HydraFusion turn.</summary>
    [JsonPropertyName("outcome")]
    public required string Outcome { get; set; }

    /// <summary>Total output tokens produced across all phases.</summary>
    [JsonPropertyName("outputTokens")]
    public required long OutputTokens { get; set; }

    /// <summary>HydraFusion orchestration pattern executed for the turn.</summary>
    [JsonPropertyName("pattern")]
    public required FusionPattern Pattern { get; set; }

    /// <summary>Number of concrete phases attempted by the turn.</summary>
    [JsonPropertyName("phaseCount")]
    public required long PhaseCount { get; set; }

    /// <summary>Total concrete model requests made across all phases.</summary>
    [JsonPropertyName("requestCount")]
    public required long RequestCount { get; set; }

    /// <summary>Synthetic HydraFusion model selected for the session.</summary>
    [JsonPropertyName("syntheticModel")]
    public required string SyntheticModel { get; set; }

    /// <summary>Total normalized AI-unit cost reported across all phases, in nano-AIU.</summary>
    [JsonPropertyName("totalNanoAiu")]
    public required double TotalNanoAiu { get; set; }

    /// <summary>Identifier of the session turn associated with the completion.</summary>
    [JsonPropertyName("turnId")]
    public required string TurnId { get; set; }
}

/// <summary>Payload of `user.message` with displayed and model-transformed content, attachments, source/delivery metadata, mode, and telemetry IDs.</summary>
public sealed partial class UserMessageData
{
    /// <summary>The agent mode that was active when this message was sent.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("agentMode")]
    public UserMessageAgentMode? AgentMode { get; set; }

    /// <summary>Files, selections, or GitHub references attached to the message.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("attachments")]
    public Attachment[]? Attachments { get; set; }

    /// <summary>The user's message text as displayed in the timeline.</summary>
    [JsonPropertyName("content")]
    public required string Content { get; set; }

    /// <summary>How this message was delivered to the agentic loop relative to loop state (idle-start vs. steering/queued while busy). The timing axis; combine with `source` (origin) for the full picture. Used for telemetry attribution.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("delivery")]
    public UserMessageDelivery? Delivery { get; set; }

    /// <summary>CAPI interaction ID for correlating this user message with its turn.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("interactionId")]
    public string? InteractionId { get; set; }

    /// <summary>True when this user message was auto-injected by autopilot's continuation loop rather than typed by the user; used to distinguish autopilot-driven turns in telemetry.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("isAutopilotContinuation")]
    public bool? IsAutopilotContinuation { get; set; }

    /// <summary>Stable identity of the logical user message, matching the ID returned by send and retained by pending queue snapshots.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("messageId")]
    public string? MessageId { get; set; }

    /// <summary>Path-backed native document attachments that stayed on the tagged_files path flow because native upload could not read them or would exceed the request size limit.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("nativeDocumentPathFallbackPaths")]
    public string[]? NativeDocumentPathFallbackPaths { get; set; }

    /// <summary>Parent agent task ID for background telemetry correlated to this user turn.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("parentAgentTaskId")]
    public string? ParentAgentTaskId { get; set; }

    /// <summary>Origin of this message, used for timeline filtering and attribution (e.g., `skill-pdf` for hidden skill injection or `agent-&lt;agent-id&gt;` for an inter-agent prompt).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("source")]
    public string? Source { get; set; }

    /// <summary>Normalized document MIME types that were sent natively instead of through tagged_files XML.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("supportedNativeDocumentMimeTypes")]
    public string[]? SupportedNativeDocumentMimeTypes { get; set; }

    /// <summary>Transformed version of the message sent to the model, with XML wrapping, timestamps, and other augmentations for prompt caching.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("transformedContent")]
    public string? TransformedContent { get; set; }

    /// <summary>The agent-loop turn ID that consumed this message; absent when no agent-loop turn consumed it.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("turnId")]
    public string? TurnId { get; set; }
}

/// <summary>Empty payload; the event signals that the pending message queue has changed.</summary>
public sealed partial class PendingMessagesModifiedData
{
}

/// <summary>Turn initialization metadata including identifier and interaction tracking.</summary>
public sealed partial class AssistantTurnStartData
{
    /// <summary>CAPI interaction ID for correlating this turn with upstream telemetry.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("interactionId")]
    public string? InteractionId { get; set; }

    /// <summary>Model identifier used for this turn, when known.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("model")]
    public string? Model { get; set; }

    /// <summary>Identifier for this turn within the agentic loop, typically a stringified turn number.</summary>
    [JsonPropertyName("turnId")]
    public required string TurnId { get; set; }
}

/// <summary>Metadata for an additional model inference attempt within an existing assistant turn.</summary>
public sealed partial class AssistantTurnRetryData
{
    /// <summary>Model identifier used for this retry, when known.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("model")]
    public string? Model { get; set; }

    /// <summary>Provider or runtime classification that caused the retry, when known.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("reason")]
    public string? Reason { get; set; }

    /// <summary>Identifier of the turn whose model inference is being retried.</summary>
    [JsonPropertyName("turnId")]
    public required string TurnId { get; set; }
}

/// <summary>Metadata for work the user interrupted while the agent was running.</summary>
public sealed partial class AgentInterruptedData
{
    /// <summary>What the agent was doing when the user interrupted it.</summary>
    [JsonPropertyName("activity")]
    public required AgentInterruptedActivity Activity { get; set; }

    /// <summary>For an interrupted model call: the provider endpoint the request targeted.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("apiEndpoint")]
    public string? ApiEndpoint { get; set; }

    /// <summary>For an interrupted model call: whether the user interrupted before any token arrived or while the response was streaming.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("cancelPhase")]
    public AgentInterruptedCancelPhase? CancelPhase { get; set; }

    /// <summary>How long the interrupted work had been running, in milliseconds.</summary>
    [JsonConverter(typeof(MillisecondsTimeSpanConverter))]
    [JsonPropertyName("elapsedMs")]
    public required TimeSpan Elapsed { get; set; }

    /// <summary>For an interrupted background-agent batch: how many background sub-agents the stop swept. Counts accepted cancellations, so an agent cancelled as a cascade of its interrupted parent is covered by that parent rather than counted again.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("interruptedAgentCount")]
    public long? InterruptedAgentCount { get; set; }

    /// <summary>For an interrupted model call: the model the request targeted.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("model")]
    public string? Model { get; set; }

    /// <summary>For a mid-stream interrupt: the observed time to first observable output, in milliseconds. Deliberately distinct from the `ttftMs` reported on a successful model call, which measures time to first stream event.</summary>
    [JsonConverter(typeof(MillisecondsTimeSpanConverter))]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("outputTtftMs")]
    public TimeSpan? OutputTtft { get; set; }

    /// <summary>For an interrupted model call: the reasoning effort the request asked for.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("reasoningEffort")]
    public string? ReasoningEffort { get; set; }

    /// <summary>Subset of `toolNames` whose tool metadata marks the tool name as safe to record unhashed in telemetry.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("safeToolNames")]
    public string[]? SafeToolNames { get; set; }

    /// <summary>Tool call identifiers that were still running.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("toolCallIds")]
    public string[]? ToolCallIds { get; set; }

    /// <summary>Names of the tools that were still running. More than one when the model requested a parallel fan-out.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("toolNames")]
    public string[]? ToolNames { get; set; }

    /// <summary>For an interrupted model call: the transport the request used.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("transport")]
    public ModelCallFailureTransport? Transport { get; set; }

    /// <summary>Zero-based agentic-loop iteration the interrupt landed in.</summary>
    [JsonPropertyName("turn")]
    public required long Turn { get; set; }
}

/// <summary>Agent intent description for current activity or plan.</summary>
public sealed partial class AssistantIntentData
{
    /// <summary>Short description of what the agent is currently doing or planning to do.</summary>
    [JsonPropertyName("intent")]
    public required string Intent { get; set; }
}

/// <summary>Experimental transient HydraFusion phase/model/role signal.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed partial class AssistantFusionPhaseStartedData
{
    /// <summary>Conversation scope in which the phase executes.</summary>
    [JsonPropertyName("conversationScope")]
    public required FusionConversationScope ConversationScope { get; set; }

    /// <summary>Identifier of the HydraFusion turn containing the phase.</summary>
    [JsonPropertyName("fusionId")]
    public required string FusionId { get; set; }

    /// <summary>Concrete model executing the phase.</summary>
    [JsonPropertyName("model")]
    public required string Model { get; set; }

    /// <summary>HydraFusion orchestration pattern containing the phase.</summary>
    [JsonPropertyName("pattern")]
    public required FusionPattern Pattern { get; set; }

    /// <summary>Stable identifier for the concrete phase.</summary>
    [JsonPropertyName("phaseId")]
    public required string PhaseId { get; set; }

    /// <summary>Kind of phase being executed.</summary>
    [JsonPropertyName("phaseKind")]
    public required FusionPhaseKind PhaseKind { get; set; }

    /// <summary>Semantic role assigned to the phase.</summary>
    [JsonPropertyName("role")]
    public required string Role { get; set; }
}

/// <summary>Experimental content-safe activity signal for a running HydraFusion phase.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed partial class AssistantFusionPhaseActivityData
{
    /// <summary>Kind of real activity observed.</summary>
    [JsonPropertyName("activity")]
    public required FusionPhaseActivityKind Activity { get; set; }

    /// <summary>Conversation scope in which the phase executes.</summary>
    [JsonPropertyName("conversationScope")]
    public required FusionConversationScope ConversationScope { get; set; }

    /// <summary>Identifier of the HydraFusion turn containing the phase.</summary>
    [JsonPropertyName("fusionId")]
    public required string FusionId { get; set; }

    /// <summary>HydraFusion orchestration pattern containing the phase.</summary>
    [JsonPropertyName("pattern")]
    public required FusionPattern Pattern { get; set; }

    /// <summary>Stable identifier for the concrete phase.</summary>
    [JsonPropertyName("phaseId")]
    public required string PhaseId { get; set; }

    /// <summary>Kind of phase currently executing.</summary>
    [JsonPropertyName("phaseKind")]
    public required FusionPhaseKind PhaseKind { get; set; }

    /// <summary>Semantic role assigned to the phase.</summary>
    [JsonPropertyName("role")]
    public required string Role { get; set; }

    /// <summary>Opaque hashed correlation token for matching tool-started and tool-completed activity within this Fusion activity stream. It is not the tool call identifier exposed by tool lifecycle events.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("toolCallId")]
    public string? ToolCallId { get; set; }

    /// <summary>Cumulative private response bytes observed for this model call. The event never includes response text.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("totalResponseSizeBytes")]
    public long? TotalResponseSizeBytes { get; set; }
}

/// <summary>Experimental durable HydraFusion phase output and lossless replay checkpoint.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed partial class AssistantFusionPhaseCompletedData
{
    /// <summary>Provider-normalized textual output produced by the phase.</summary>
    [JsonPropertyName("content")]
    public required string Content { get; set; }

    /// <summary>Conversation scope in which the phase executed.</summary>
    [JsonPropertyName("conversationScope")]
    public required FusionConversationScope ConversationScope { get; set; }

    /// <summary>Elapsed execution time for the phase in milliseconds.</summary>
    [JsonPropertyName("durationMs")]
    public required double DurationMs { get; set; }

    /// <summary>Identifier of the HydraFusion turn containing the phase.</summary>
    [JsonPropertyName("fusionId")]
    public required string FusionId { get; set; }

    /// <summary>Concrete model that executed the phase.</summary>
    [JsonPropertyName("model")]
    public required string Model { get; set; }

    /// <summary>Stable identifier for the completed phase.</summary>
    [JsonPropertyName("phaseId")]
    public required string PhaseId { get; set; }

    /// <summary>Kind of phase that completed.</summary>
    [JsonPropertyName("phaseKind")]
    public required FusionPhaseKind PhaseKind { get; set; }

    /// <summary>Exact provider-normalized message used to reconstruct canonical model history.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonInclude]
    [JsonPropertyName("projectionMessage")]
    internal JsonElement? ProjectionMessage { get; set; }

    /// <summary>Projection action for the exact internal message.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonInclude]
    [JsonPropertyName("projectionMode")]
    internal FusionProjectionMode? ProjectionMode { get; set; }

    /// <summary>Semantic role assigned to the completed phase.</summary>
    [JsonPropertyName("role")]
    public required string Role { get; set; }

    /// <summary>Terminal request held outside canonical state until selected by the final commit.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonInclude]
    [JsonPropertyName("stagedTerminal")]
    internal FusionStagedTerminal? StagedTerminal { get; set; }

    /// <summary>Durable outcome status of the phase.</summary>
    [JsonPropertyName("status")]
    public required FusionPhaseStatus Status { get; set; }

    /// <summary>Aggregate concrete-model usage consumed by the phase.</summary>
    [JsonPropertyName("usage")]
    public required FusionPhaseUsage Usage { get; set; }

    /// <summary>Structured judge or critic verdict, when the phase produces one.</summary>
    [JsonPropertyName("verdict")]
    public string? Verdict { get; set; }
}

/// <summary>Experimental durable typed HydraFusion phase failure and degradation transition.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed partial class AssistantFusionPhaseFailedData
{
    /// <summary>Conversation scope in which the phase executed.</summary>
    [JsonPropertyName("conversationScope")]
    public required FusionConversationScope ConversationScope { get; set; }

    /// <summary>Identifier of the fallback phase used to continue the turn after degradation.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("degradedToPhaseId")]
    public string? DegradedToPhaseId { get; set; }

    /// <summary>Elapsed execution time before the phase failed, in milliseconds.</summary>
    [JsonPropertyName("durationMs")]
    public required double DurationMs { get; set; }

    /// <summary>Provider or execution error detail, when available.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("errorMessage")]
    public string? ErrorMessage { get; set; }

    /// <summary>Identifier of the HydraFusion turn containing the phase.</summary>
    [JsonPropertyName("fusionId")]
    public required string FusionId { get; set; }

    /// <summary>Concrete model that attempted the phase.</summary>
    [JsonPropertyName("model")]
    public required string Model { get; set; }

    /// <summary>Stable identifier for the failed phase.</summary>
    [JsonPropertyName("phaseId")]
    public required string PhaseId { get; set; }

    /// <summary>Kind of phase that failed.</summary>
    [JsonPropertyName("phaseKind")]
    public required FusionPhaseKind PhaseKind { get; set; }

    /// <summary>Stable machine-readable reason for the phase failure.</summary>
    [JsonPropertyName("reason")]
    public required string Reason { get; set; }

    /// <summary>Semantic role assigned to the failed phase.</summary>
    [JsonPropertyName("role")]
    public required string Role { get; set; }

    /// <summary>Durable outcome status of the phase.</summary>
    [JsonPropertyName("status")]
    public required FusionPhaseStatus Status { get; set; }

    /// <summary>Aggregate concrete-model usage consumed before the failure.</summary>
    [JsonPropertyName("usage")]
    public required FusionPhaseUsage Usage { get; set; }
}

/// <summary>Live progress signal for a provider-hosted server tool (e.g. hosted web search) while it runs, before the finalized serverTools envelope lands on the terminal assistant.message.</summary>
public sealed partial class AssistantServerToolProgressData
{
    /// <summary>Kind of hosted server tool that is running. Only `web_search` is emitted today.</summary>
    [JsonPropertyName("kind")]
    public required string Kind { get; set; }

    /// <summary>Position of the hosted tool call in the response output. Stable across the call's lifecycle events (unlike the provider's per-event item id, which CAPI rotates), so the host keys the live in-progress row on it.</summary>
    [JsonPropertyName("outputIndex")]
    public required long OutputIndex { get; set; }

    /// <summary>Lifecycle status of the hosted call: `in_progress`, `searching`, or `completed`.</summary>
    [JsonPropertyName("status")]
    public required string Status { get; set; }
}

/// <summary>Assistant reasoning content for timeline display with complete thinking text.</summary>
public sealed partial class AssistantReasoningData
{
    /// <summary>The complete extended thinking text from the model.</summary>
    [JsonPropertyName("content")]
    public required string Content { get; set; }

    /// <summary>Unique identifier for this reasoning block.</summary>
    [JsonPropertyName("reasoningId")]
    public required string ReasoningId { get; set; }

    /// <summary>Per-request treatment/eligibility signal returned by the Copilot API in the `X-GitHub-Copilot-Request-TE` response header for the associated model call; `false` when the header was absent or unparseable.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("rte")]
    public bool? Rte { get; set; }
}

/// <summary>Streaming reasoning delta for incremental extended thinking updates.</summary>
public sealed partial class AssistantReasoningDeltaData
{
    /// <summary>Incremental text chunk to append to the reasoning content.</summary>
    [JsonPropertyName("deltaContent")]
    public required string DeltaContent { get; set; }

    /// <summary>Reasoning block ID this delta belongs to, matching the corresponding assistant.reasoning event.</summary>
    [JsonPropertyName("reasoningId")]
    public required string ReasoningId { get; set; }
}

/// <summary>Streaming tool-call input delta for incremental tool-call updates.</summary>
public sealed partial class AssistantToolCallDeltaData
{
    /// <summary>Raw provider tool input fragment to append for this tool call. Function/tool-use providers stream serialized JSON argument text (so newlines inside JSON string values may appear as escaped `\n` until the accumulated JSON is parsed); custom tool calls stream raw custom input.</summary>
    [JsonPropertyName("inputDelta")]
    public required string InputDelta { get; set; }

    /// <summary>Tool call ID this delta belongs to, matching the corresponding assistant.message tool request.</summary>
    [JsonPropertyName("toolCallId")]
    public required string ToolCallId { get; set; }

    /// <summary>Name of the tool being invoked, when known from the stream.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("toolName")]
    public string? ToolName { get; set; }

    /// <summary>Tool call type, when known from the stream.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("toolType")]
    public AssistantMessageToolRequestType? ToolType { get; set; }
}

/// <summary>Streaming response progress with cumulative byte count.</summary>
public sealed partial class AssistantStreamingDeltaData
{
    /// <summary>Cumulative total bytes received from the streaming response so far.</summary>
    [JsonPropertyName("totalResponseSizeBytes")]
    public required long TotalResponseSizeBytes { get; set; }
}

/// <summary>Assistant response containing text content, optional tool requests, and interaction metadata.</summary>
public sealed partial class AssistantMessageData
{
    /// <summary>Provider's completion / response identifier; shared across all chunks of a single API call. Used to group multi-chunk assistant utterances.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("apiCallId")]
    public string? ApiCallId { get; set; }

    /// <summary>Total messages the model call's response was split into, one per reasoning boundary. Absent for a single-message response; the last chunk is the one where chunkIndex is chunkCount - 1.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("chunkCount")]
    public long? ChunkCount { get; set; }

    /// <summary>Zero-based position of this message within its model call's response. Absent when the response was not split into chunks.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("chunkIndex")]
    public long? ChunkIndex { get; set; }

    /// <summary>Provider-agnostic citations linking spans of this message's content to the sources that support them. Experimental; only populated when citation emission is enabled.</summary>
    [Experimental(Diagnostics.Experimental)]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("citations")]
    public Citations? Citations { get; set; }

    /// <summary>Client-minted request id (x-request-id header) echoed by the server. Distinct from requestId (x-github-request-id) and serviceRequestId (x-copilot-service-request-id).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("clientRequestId")]
    public string? ClientRequestId { get; set; }

    /// <summary>The assistant's text response content.</summary>
    [JsonPropertyName("content")]
    public required string Content { get; set; }

    /// <summary>Encrypted reasoning content from OpenAI models. Session-bound and stripped on resume.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("encryptedContent")]
    public string? EncryptedContent { get; set; }

    /// <summary>Experimental HydraFusion source attribution for this ordinary authoritative assistant message.</summary>
    [Experimental(Diagnostics.Experimental)]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("fusion")]
    public FusionAttribution? Fusion { get; set; }

    /// <summary>CAPI interaction ID for correlating this message with upstream telemetry.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("interactionId")]
    public string? InteractionId { get; set; }

    /// <summary>Unique identifier for this assistant message.</summary>
    [JsonPropertyName("messageId")]
    public required string MessageId { get; set; }

    /// <summary>Model that produced this assistant message, if known.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("model")]
    public string? Model { get; set; }

    /// <summary>Actual output token count from the API response (completion_tokens), used for accurate token accounting.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("outputTokens")]
    public long? OutputTokens { get; set; }

    /// <summary>Tool call ID of the parent tool invocation when this event originates from a sub-agent.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
#if NET5_0_OR_GREATER
    [Obsolete("This member is deprecated and will be removed in a future version.", DiagnosticId = "GHCP001")]
#endif
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("parentToolCallId")]
    public string? ParentToolCallId { get; set; }

    /// <summary>Generation phase for phased-output models (e.g., thinking vs. response phases).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("phase")]
    public string? Phase { get; set; }

    /// <summary>Neutral provider-tagged reasoning content blocks preserved verbatim for round-tripping. `reasoningText` and `reasoningOpaque` are a lossy derived view of these blocks, retained for display.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("reasoningBlocks")]
    public AssistantMessageReasoningBlocks? ReasoningBlocks { get; set; }

    /// <summary>Opaque/encrypted extended thinking data from Anthropic models. Session-bound and stripped on resume.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("reasoningOpaque")]
    public string? ReasoningOpaque { get; set; }

    /// <summary>Readable reasoning text from the model's extended thinking.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("reasoningText")]
    public string? ReasoningText { get; set; }

    /// <summary>OpenAI-compatible wire field the provider used for reasoning (e.g. reasoning_content/reasoning). Populated only when non-canonical, so the dialect round-trips across turns.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("reasoningWireField")]
    public string? ReasoningWireField { get; set; }

    /// <summary>GitHub request tracing ID (x-github-request-id header) for correlating with server-side logs.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("requestId")]
    public string? RequestId { get; set; }

    /// <summary>Per-request treatment/eligibility signal returned by the Copilot API in the `X-GitHub-Copilot-Request-TE` response header for the associated model call; `false` when the header was absent or unparseable.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("rte")]
    public bool? Rte { get; set; }

    /// <summary>Neutral provider-tagged server-side tool-use payload (tool search, advisor) for verbatim round-tripping.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("serverTools")]
    public AssistantMessageServerTools? ServerTools { get; set; }

    /// <summary>Copilot service request ID (x-copilot-service-request-id header) for CAPI log correlation.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("serviceRequestId")]
    public string? ServiceRequestId { get; set; }

    /// <summary>Tool invocations requested by the assistant in this message.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("toolRequests")]
    public AssistantMessageToolRequest[]? ToolRequests { get; set; }

    /// <summary>Identifier for the agent loop turn that produced this message, matching the corresponding assistant.turn_start event.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("turnId")]
    public string? TurnId { get; set; }
}

/// <summary>Streaming assistant message start metadata.</summary>
public sealed partial class AssistantMessageStartData
{
    /// <summary>Message ID this start event belongs to, matching subsequent deltas and assistant.message.</summary>
    [JsonPropertyName("messageId")]
    public required string MessageId { get; set; }

    /// <summary>Generation phase this message belongs to for phased-output models.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("phase")]
    public string? Phase { get; set; }
}

/// <summary>Streaming assistant message delta for incremental response updates.</summary>
public sealed partial class AssistantMessageDeltaData
{
    /// <summary>Incremental text chunk to append to the message content.</summary>
    [JsonPropertyName("deltaContent")]
    public required string DeltaContent { get; set; }

    /// <summary>Message ID this delta belongs to, matching the corresponding assistant.message event.</summary>
    [JsonPropertyName("messageId")]
    public required string MessageId { get; set; }

    /// <summary>Tool call ID of the parent tool invocation when this event originates from a sub-agent.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
#if NET5_0_OR_GREATER
    [Obsolete("This member is deprecated and will be removed in a future version.", DiagnosticId = "GHCP001")]
#endif
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("parentToolCallId")]
    public string? ParentToolCallId { get; set; }
}

/// <summary>Turn completion metadata including the turn identifier.</summary>
public sealed partial class AssistantTurnEndData
{
    /// <summary>Model identifier used for this turn, when known.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("model")]
    public string? Model { get; set; }

    /// <summary>Identifier of the turn that has ended, matching the corresponding assistant.turn_start event.</summary>
    [JsonPropertyName("turnId")]
    public required string TurnId { get; set; }
}

/// <summary>Payload emitted whenever the main agent's processing loop goes idle, including while related background work (running agents or in-flight attached shell commands) is still pending and the session-level idle event is therefore deferred.</summary>
public sealed partial class AssistantIdleData
{
    /// <summary>True when the preceding agentic loop was cancelled via abort signal.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("aborted")]
    public bool? Aborted { get; set; }
}

/// <summary>LLM API call usage metrics including tokens, costs, quotas, and billing information.</summary>
public sealed partial class AssistantUsageData
{
    /// <summary>Number of accepted speculative prediction tokens.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("acceptedPredictionTokens")]
    public long? AcceptedPredictionTokens { get; set; }

    /// <summary>Completion ID from the model provider (e.g., chatcmpl-abc123).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("apiCallId")]
    public string? ApiCallId { get; set; }

    /// <summary>API endpoint used for this model call, matching CAPI supported_endpoints vocabulary.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("apiEndpoint")]
    public AssistantUsageApiEndpoint? ApiEndpoint { get; set; }

    /// <summary>Number of tools available to the model for this call.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonInclude]
    [JsonPropertyName("availableToolCount")]
    internal long? AvailableToolCount { get; set; }

    /// <summary>Whether the provider reported prompt-cache usage details for this call.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonInclude]
    [JsonPropertyName("cacheDetailsReported")]
    internal bool? CacheDetailsReported { get; set; }

    /// <summary>Updated prompt-cache expiration for this model call. Present only when the call establishes or refreshes known cache state.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("cacheExpiresAt")]
    public DateTimeOffset? CacheExpiresAt { get; set; }

    /// <summary>Number of tokens read from prompt cache.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("cacheReadTokens")]
    public long? CacheReadTokens { get; set; }

    /// <summary>Effective prompt-cache lifetime in seconds for this call.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonInclude]
    [JsonPropertyName("cacheTtlSeconds")]
    internal long? CacheTtlSeconds { get; set; }

    /// <summary>Number of tokens written to prompt cache.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("cacheWriteTokens")]
    public long? CacheWriteTokens { get; set; }

    /// <summary>Whether the model response was blocked or truncated by content filtering (finish_reason === 'content_filter'). For Anthropic models this corresponds to a 'refusal' stop reason.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("contentFilterTriggered")]
    public bool? ContentFilterTriggered { get; set; }

    /// <summary>Per-request cost and usage data from the CAPI copilot_usage response field.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("copilotUsage")]
    public AssistantUsageCopilotUsage? CopilotUsage { get; set; }

    /// <summary>Model multiplier cost for billing purposes.</summary>
    [Experimental(Diagnostics.Experimental)]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("cost")]
    public double? Cost { get; set; }

    /// <summary>Duration of the API call in milliseconds.</summary>
    [JsonConverter(typeof(MillisecondsTimeSpanConverter))]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("duration")]
    public TimeSpan? Duration { get; set; }

    /// <summary>Finish reason reported by the model for this API call (e.g. "stop", "length", "tool_calls", "content_filter"). Normalized to OpenAI vocabulary; for Anthropic models a "refusal" stop reason maps to "content_filter".</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("finishReason")]
    public string? FinishReason { get; set; }

    /// <summary>How the prompt-cache frontier was determined for this call.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonInclude]
    [JsonPropertyName("frontierSource")]
    internal string? FrontierSource { get; set; }

    /// <summary>Experimental HydraFusion attribution for this concrete model call's usage.</summary>
    [Experimental(Diagnostics.Experimental)]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("fusion")]
    public FusionAttribution? Fusion { get; set; }

    /// <summary>What initiated this API call (e.g., "sub-agent", "mcp-sampling"); absent for user-initiated calls.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("initiator")]
    public string? Initiator { get; set; }

    /// <summary>Number of input tokens consumed.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("inputTokens")]
    public long? InputTokens { get; set; }

    /// <summary>Coarse classification of the interaction that produced this call, mirroring the session's per-request agent context (e.g. `conversation-agent`, `conversation-subagent`, `conversation-sampling`, `conversation-background`, `conversation-compaction`, `conversation-user`). Non-billing; lets consumers attribute a model call to a call class (e.g. sub-agent/sidekick) independently of the billing initiator. Absent when the runtime did not classify the request.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("interactionType")]
    public string? InteractionType { get; set; }

    /// <summary>Average inter-token latency in milliseconds. Only available for streaming requests.</summary>
    [JsonConverter(typeof(MillisecondsTimeSpanConverter))]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("interTokenLatencyMs")]
    public TimeSpan? InterTokenLatency { get; set; }

    /// <summary>Whether Auto mode was selected for this model call.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("isAuto")]
    public bool? IsAuto { get; set; }

    /// <summary>Whether this model call used a bring-your-own-key provider.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("isByok")]
    public bool? IsByok { get; set; }

    /// <summary>Requested maximum output tokens used for this model call.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("maxOutputTokens")]
    public long? MaxOutputTokens { get; set; }

    /// <summary>Effective maximum prompt-token limit used for this model call.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("maxPromptTokens")]
    public long? MaxPromptTokens { get; set; }

    /// <summary>Model identifier used for this API call.</summary>
    [JsonPropertyName("model")]
    public required string Model { get; set; }

    /// <summary>Number of tool calls returned by the model.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonInclude]
    [JsonPropertyName("numToolCalls")]
    internal long? NumToolCalls { get; set; }

    /// <summary>Number of output tokens produced.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("outputTokens")]
    public long? OutputTokens { get; set; }

    /// <summary>Time to first observable model output in milliseconds. Includes text, reasoning, and tool-call output; only available for streaming requests that produce observable output.</summary>
    [JsonConverter(typeof(MillisecondsTimeSpanConverter))]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("outputTtftMs")]
    public TimeSpan? OutputTtft { get; set; }

    /// <summary>Parent tool call ID when this usage originates from a sub-agent.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
#if NET5_0_OR_GREATER
    [Obsolete("This member is deprecated and will be removed in a future version.", DiagnosticId = "GHCP001")]
#endif
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("parentToolCallId")]
    public string? ParentToolCallId { get; set; }

    /// <summary>GitHub request tracing ID (x-github-request-id header) for server-side log correlation.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("providerCallId")]
    public string? ProviderCallId { get; set; }

    /// <summary>Per-quota resource usage snapshots, keyed by quota identifier.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonInclude]
    [JsonPropertyName("quotaSnapshots")]
    internal IDictionary<string, AssistantUsageQuotaSnapshot>? QuotaSnapshots { get; set; }

    /// <summary>Reasoning effort level used for model calls, if applicable (e.g. "none", "low", "medium", "high", "xhigh", "max").</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("reasoningEffort")]
    public string? ReasoningEffort { get; set; }

    /// <summary>Reasoning summary mode used for this model call, if applicable.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("reasoningSummary")]
    public ReasoningSummary? ReasoningSummary { get; set; }

    /// <summary>Number of output tokens used for reasoning (e.g., chain-of-thought).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("reasoningTokens")]
    public long? ReasoningTokens { get; set; }

    /// <summary>Number of rejected speculative prediction tokens.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("rejectedPredictionTokens")]
    public long? RejectedPredictionTokens { get; set; }

    /// <summary>Per-request treatment/eligibility signal returned by the Copilot API in the `X-GitHub-Copilot-Request-TE` response header for the associated model call; `false` when the header was absent or unparseable.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("rte")]
    public bool? Rte { get; set; }

    /// <summary>Copilot service request ID (x-copilot-service-request-id header) for CAPI log correlation.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("serviceRequestId")]
    public string? ServiceRequestId { get; set; }

    /// <summary>Time to first token in milliseconds. Only available for streaming requests.</summary>
    [JsonConverter(typeof(MillisecondsTimeSpanConverter))]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("timeToFirstTokenMs")]
    public TimeSpan? TimeToFirstToken { get; set; }

    /// <summary>Tool-call counts keyed by tool name.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonInclude]
    [JsonPropertyName("toolCounts")]
    internal IDictionary<string, long>? ToolCounts { get; set; }

    /// <summary>Number of tokens used by tool definitions for this call.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonInclude]
    [JsonPropertyName("toolTokenCount")]
    internal long? ToolTokenCount { get; set; }

    /// <summary>Transport used for this model call (http or websocket).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("transport")]
    public AssistantUsageTransport? Transport { get; set; }
}

/// <summary>A detected loss of a previously cached prompt prefix.</summary>
public sealed partial class PromptCacheBreakData
{
    /// <summary>Request state whose cached prefix fell short.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonInclude]
    [JsonPropertyName("afterRequest")]
    internal JsonElement? AfterRequest { get; set; }

    /// <summary>Name of the sub-agent whose conversation broke, stamped by the parent bridge.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonInclude]
    [JsonPropertyName("agentName")]
    internal string? AgentName { get; set; }

    /// <summary>Request state that established the prior cache frontier.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonInclude]
    [JsonPropertyName("beforeRequest")]
    internal JsonElement? BeforeRequest { get; set; }

    /// <summary>Names of the cache-configuration fields that changed.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonInclude]
    [JsonPropertyName("cacheConfigChangedFields")]
    internal string[]? CacheConfigChangedFields { get; set; }

    /// <summary>All reasons that contributed to the cache break, ordered by precedence.</summary>
    [JsonPropertyName("contributingReasons")]
    public required string[] ContributingReasons { get; set; }

    /// <summary>Prior cached prompt frontier in tokens.</summary>
    [JsonPropertyName("frontierTokens")]
    public required long FrontierTokens { get; set; }

    /// <summary>Model that held the prior cache frontier, when the call changed models.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonInclude]
    [JsonPropertyName("modelFrom")]
    internal string? ModelFrom { get; set; }

    /// <summary>Model this call targeted, when the call changed models.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonInclude]
    [JsonPropertyName("modelTo")]
    internal string? ModelTo { get; set; }

    /// <summary>The highest-precedence reason for the cache break.</summary>
    [JsonPropertyName("primaryReason")]
    public required string PrimaryReason { get; set; }

    /// <summary>Fraction of the prior cache frontier that survived.</summary>
    [JsonPropertyName("retentionRatio")]
    public required double RetentionRatio { get; set; }

    /// <summary>Index of the first conversation message whose content changed.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonInclude]
    [JsonPropertyName("rewriteMessageIndex")]
    internal long? RewriteMessageIndex { get; set; }

    /// <summary>Shape of the history rewrite, for example whether the history grew or shrank.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonInclude]
    [JsonPropertyName("rewriteShape")]
    internal string? RewriteShape { get; set; }

    /// <summary>Subsystems that announced a history rewrite before this call, for example compaction or truncation.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonInclude]
    [JsonPropertyName("rewriteSource")]
    internal string[]? RewriteSource { get; set; }

    /// <summary>Cached prefix tokens lost since the prior call.</summary>
    [JsonPropertyName("shortfallTokens")]
    public required long ShortfallTokens { get; set; }

    /// <summary>Number of cached prefix tokens that survived.</summary>
    [JsonPropertyName("survivedTokens")]
    public required long SurvivedTokens { get; set; }

    /// <summary>Names of the system-prompt segments whose content changed.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonInclude]
    [JsonPropertyName("systemSegmentsChanged")]
    internal string[]? SystemSegmentsChanged { get; set; }

    /// <summary>Telemetry-safe names of tools added since the prior call.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonInclude]
    [JsonPropertyName("toolsAdded")]
    internal string[]? ToolsAdded { get; set; }

    /// <summary>Raw names of tools added since the prior call, restricted because a tool name can be user-authored.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonInclude]
    [JsonPropertyName("toolsAddedRaw")]
    internal string[]? ToolsAddedRaw { get; set; }

    /// <summary>Telemetry-safe names of tools whose definition changed since the prior call.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonInclude]
    [JsonPropertyName("toolsRedefined")]
    internal string[]? ToolsRedefined { get; set; }

    /// <summary>Raw names of tools redefined since the prior call, restricted because a tool name can be user-authored.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonInclude]
    [JsonPropertyName("toolsRedefinedRaw")]
    internal string[]? ToolsRedefinedRaw { get; set; }

    /// <summary>Telemetry-safe names of tools removed since the prior call.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonInclude]
    [JsonPropertyName("toolsRemoved")]
    internal string[]? ToolsRemoved { get; set; }

    /// <summary>Raw names of tools removed since the prior call, restricted because a tool name can be user-authored.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonInclude]
    [JsonPropertyName("toolsRemovedRaw")]
    internal string[]? ToolsRemovedRaw { get; set; }

    /// <summary>Whether the tool list kept its members but changed their order.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonInclude]
    [JsonPropertyName("toolsReordered")]
    internal bool? ToolsReordered { get; set; }
}

/// <summary>Failed LLM API call metadata for telemetry.</summary>
public sealed partial class ModelCallFailureData
{
    /// <summary>Completion ID from the model provider (e.g., chatcmpl-abc123).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("apiCallId")]
    public string? ApiCallId { get; set; }

    /// <summary>API endpoint used for this model call, matching CAPI supported_endpoints vocabulary.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("apiEndpoint")]
    public AssistantUsageApiEndpoint? ApiEndpoint { get; set; }

    /// <summary>For HTTP 400 failures only: whether the response carried a structured CAPI error envelope (structured_error, a deterministic validation failure) or no error body (bodyless, the transient gateway/proxy signature). Absent for non-400 failures.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("badRequestKind")]
    public ModelCallFailureBadRequestKind? BadRequestKind { get; set; }

    /// <summary>Duration of the failed API call in milliseconds.</summary>
    [JsonConverter(typeof(MillisecondsTimeSpanConverter))]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("durationMs")]
    public TimeSpan? Duration { get; set; }

    /// <summary>For HTTP 400 failures only: the `code` from the CAPI error envelope (e.g. 'model_max_prompt_tokens_exceeded') identifying which deterministic validation failure occurred. Raw server-controlled string, emitted only through restricted telemetry. Absent for bodyless or non-400 failures.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("errorCode")]
    public string? ErrorCode { get; set; }

    /// <summary>Raw provider/runtime error message for restricted telemetry.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("errorMessage")]
    public string? ErrorMessage { get; set; }

    /// <summary>For HTTP 400 failures only: the `type` from the CAPI error envelope (e.g. 'websocket_error'), a coarser companion to errorCode for envelopes that carry no code. Raw server-controlled string, emitted only through restricted telemetry. Absent for bodyless or non-400 failures.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("errorType")]
    public string? ErrorType { get; set; }

    /// <summary>Whether the failure originated from an API response or the request transport.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("failureKind")]
    public ModelCallFailureKind? FailureKind { get; set; }

    /// <summary>Experimental HydraFusion attribution for this failed concrete model call.</summary>
    [Experimental(Diagnostics.Experimental)]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("fusion")]
    public FusionAttribution? Fusion { get; set; }

    /// <summary>What initiated this API call (e.g., "sub-agent", "mcp-sampling"); absent for user-initiated calls.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("initiator")]
    public string? Initiator { get; set; }

    /// <summary>Authoritative interaction classification for the failed call, matching `assistant.usage.interactionType` (for example `conversation-agent`, `conversation-subagent`, or `conversation-sampling`). Absent when the producer cannot classify the interaction.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("interactionType")]
    public string? InteractionType { get; set; }

    /// <summary>Whether the session selected Auto mode for the failed call.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("isAuto")]
    public bool? IsAuto { get; set; }

    /// <summary>Whether the failed call used a bring-your-own-key provider.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("isByok")]
    public bool? IsByok { get; set; }

    /// <summary>Effective maximum output-token limit for the failed call.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("maxOutputTokens")]
    public long? MaxOutputTokens { get; set; }

    /// <summary>Effective maximum prompt-token limit for the failed call.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("maxPromptTokens")]
    public long? MaxPromptTokens { get; set; }

    /// <summary>Model identifier used for the failed API call.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("model")]
    public string? Model { get; set; }

    /// <summary>GitHub request tracing ID (x-github-request-id header) for server-side log correlation.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("providerCallId")]
    public string? ProviderCallId { get; set; }

    /// <summary>Per-quota usage snapshots parsed from the failed response's quota headers, keyed by quota identifier. Present when the error response carried quota headers (e.g. a 402 once the additional spend limit is reached) so the UI can refresh the quota display on failure.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonInclude]
    [JsonPropertyName("quotaSnapshots")]
    internal IDictionary<string, AssistantUsageQuotaSnapshot>? QuotaSnapshots { get; set; }

    /// <summary>Reasoning effort level used for the failed model call, if applicable.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("reasoningEffort")]
    public string? ReasoningEffort { get; set; }

    /// <summary>Content-free structural summary of the failing request. Contains only counts and shape flags (no prompt content), so it is safe for unrestricted telemetry. Populated only for client-error (4xx) failures.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("requestFingerprint")]
    public ModelCallFailureRequestFingerprint? RequestFingerprint { get; set; }

    /// <summary>Per-request treatment/eligibility signal returned by the Copilot API in the `X-GitHub-Copilot-Request-TE` response header for the associated model call; `false` when the header was absent or unparseable.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("rte")]
    public bool? Rte { get; set; }

    /// <summary>Copilot service request ID (x-copilot-service-request-id header) for CAPI log correlation.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("serviceRequestId")]
    public string? ServiceRequestId { get; set; }

    /// <summary>Where the failed model call originated.</summary>
    [JsonPropertyName("source")]
    public required ModelCallFailureSource Source { get; set; }

    /// <summary>HTTP status code from the failed request.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("statusCode")]
    public int? StatusCode { get; set; }

    /// <summary>Transport used for the failed model call (http or websocket).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("transport")]
    public ModelCallFailureTransport? Transport { get; set; }
}

/// <summary>Final lifecycle outcome for one logical model dispatch. A logical dispatch may include internal reconnect or fallback work, so event count is not provider HTTP-request count.</summary>
public sealed partial class ModelCallFinishedData
{
    /// <summary>Whether an accepted successful response requested the exact name and command semantics of a built-in file edit tool, including an external tool explicitly replacing that built-in name. Absent when the logical dispatch did not produce an accepted response.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("containsBuiltInFileEditRequest")]
    public bool? ContainsBuiltInFileEditRequest { get; set; }

    /// <summary>Monotonic elapsed time spent in the logical model dispatch, including any internal transport reconnect or fallback and excluding orchestrator retry backoff, tool execution, confirmations, and post-response processing.</summary>
    [JsonConverter(typeof(MillisecondsTimeSpanConverter))]
    [JsonPropertyName("dispatchDurationMs")]
    public required TimeSpan DispatchDuration { get; set; }

    /// <summary>Version of the built-in file-edit semantic classifier used for this event.</summary>
    [JsonPropertyName("editClassifierVersion")]
    public required long EditClassifierVersion { get; set; }

    /// <summary>Identifier of the user interaction that owns the model dispatch, matching assistant.turn_start.interactionId when available.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("interactionId")]
    public string? InteractionId { get; set; }

    /// <summary>Final outcome after post-response acceptance processing.</summary>
    [JsonPropertyName("outcome")]
    public required ModelCallFinishedOutcome Outcome { get; set; }

    /// <summary>Agent-loop iteration within the interaction that initiated the model dispatch.</summary>
    [JsonPropertyName("turnId")]
    public required string TurnId { get; set; }
}

/// <summary>Model API dispatch metadata for internal telemetry.</summary>
public sealed partial class ModelCallStartData
{
    /// <summary>Experimental HydraFusion attribution for this concrete model call.</summary>
    [Experimental(Diagnostics.Experimental)]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("fusion")]
    public FusionAttribution? Fusion { get; set; }

    /// <summary>Model identifier used for this API call, when known.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("model")]
    public string? Model { get; set; }

    /// <summary>Previous response or interaction identifier included in the model request, when present.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonInclude]
    [JsonPropertyName("previousResponseId")]
    internal string? PreviousResponseId { get; set; }

    /// <summary>Identifier of the assistant turn that initiated the model call.</summary>
    [JsonPropertyName("turnId")]
    public required string TurnId { get; set; }
}

/// <summary>Turn abort information including the reason for termination.</summary>
public sealed partial class AbortData
{
    /// <summary>Finite reason code describing why the current turn was aborted.</summary>
    [JsonPropertyName("reason")]
    public required AbortReason Reason { get; set; }
}

/// <summary>User-initiated tool invocation request with tool name and arguments.</summary>
public sealed partial class ToolUserRequestedData
{
    /// <summary>Arguments for the tool invocation.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("arguments")]
    public JsonElement? Arguments { get; set; }

    /// <summary>Unique identifier for this tool call.</summary>
    [JsonPropertyName("toolCallId")]
    public required string ToolCallId { get; set; }

    /// <summary>Name of the tool the user wants to invoke.</summary>
    [JsonPropertyName("toolName")]
    public required string ToolName { get; set; }
}

/// <summary>Tool execution startup details including MCP server information when applicable.</summary>
public sealed partial class ToolExecutionStartData
{
    /// <summary>Arguments passed to the tool.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("arguments")]
    public JsonElement? Arguments { get; set; }

    /// <summary>When true, the tool output should be displayed expanded (verbatim) in the CLI timeline.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("displayVerbatim")]
    public bool? DisplayVerbatim { get; set; }

    /// <summary>Experimental HydraFusion attribution for this tool execution.</summary>
    [Experimental(Diagnostics.Experimental)]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("fusion")]
    public FusionAttribution? Fusion { get; set; }

    /// <summary>Name of the MCP server hosting this tool, when the tool is an MCP tool.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("mcpServerName")]
    public string? McpServerName { get; set; }

    /// <summary>Original tool name on the MCP server, when the tool is an MCP tool.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("mcpToolName")]
    public string? McpToolName { get; set; }

    /// <summary>Model identifier that generated this tool call.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("model")]
    public string? Model { get; set; }

    /// <summary>Tool call ID of the parent tool invocation when this event originates from a sub-agent.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
#if NET5_0_OR_GREATER
    [Obsolete("This member is deprecated and will be removed in a future version.", DiagnosticId = "GHCP001")]
#endif
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("parentToolCallId")]
    public string? ParentToolCallId { get; set; }

    /// <summary>Per-request treatment/eligibility signal returned by the Copilot API in the `X-GitHub-Copilot-Request-TE` response header for the associated model call; `false` when the header was absent or unparseable.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("rte")]
    public bool? Rte { get; set; }

    /// <summary>Shell-tool path hints derived from the command at start time for shell tools (bash/powershell/local_shell). Produced by the same shell-aware extractor as PermissionRequestShell.possiblePaths, so it is present even when the command is auto-approved and no permission request fires. Absent for non-shell tools.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("shellToolInfo")]
    public ToolExecutionStartShellToolInfo? ShellToolInfo { get; set; }

    /// <summary>Unique identifier for this tool call.</summary>
    [JsonPropertyName("toolCallId")]
    public required string ToolCallId { get; set; }

    /// <summary>Tool definition metadata, present for MCP tools with MCP Apps support.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("toolDescription")]
    public ToolExecutionStartToolDescription? ToolDescription { get; set; }

    /// <summary>Name of the tool being executed.</summary>
    [JsonPropertyName("toolName")]
    public required string ToolName { get; set; }

    /// <summary>Identifier for the agent loop turn this tool was invoked in, matching the corresponding assistant.turn_start event.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("turnId")]
    public string? TurnId { get; set; }
}

/// <summary>Streaming tool execution output for incremental result display.</summary>
public sealed partial class ToolExecutionPartialResultData
{
    /// <summary>Incremental output chunk from the running tool.</summary>
    [JsonPropertyName("partialOutput")]
    public required string PartialOutput { get; set; }

    /// <summary>Tool call ID this partial result belongs to.</summary>
    [JsonPropertyName("toolCallId")]
    public required string ToolCallId { get; set; }
}

/// <summary>Tool execution progress notification with status message.</summary>
public sealed partial class ToolExecutionProgressData
{
    /// <summary>Human-readable progress status message (e.g., from an MCP server).</summary>
    [JsonPropertyName("progressMessage")]
    public required string ProgressMessage { get; set; }

    /// <summary>Tool call ID this progress notification belongs to.</summary>
    [JsonPropertyName("toolCallId")]
    public required string ToolCallId { get; set; }
}

/// <summary>Tool execution completion results including success status, detailed output, and error information.</summary>
public sealed partial class ToolExecutionCompleteData
{
    /// <summary>Error details when the tool execution failed.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("error")]
    public ToolExecutionCompleteError? Error { get; set; }

    /// <summary>Experimental HydraFusion attribution for this tool completion.</summary>
    [Experimental(Diagnostics.Experimental)]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("fusion")]
    public FusionAttribution? Fusion { get; set; }

    /// <summary>CAPI interaction ID for correlating this tool execution with upstream telemetry.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("interactionId")]
    public string? InteractionId { get; set; }

    /// <summary>Whether this tool call was explicitly requested by the user rather than the assistant.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("isUserRequested")]
    public bool? IsUserRequested { get; set; }

    /// <summary>FIDES IFC label projected from tool ingress metadata (MCP `CallToolResult._meta` or synthesized built-in ingress labels). Persisted as `{ ifc: ... }` so the label survives session resume, including model-visible failure results. Experimental.</summary>
    [Experimental(Diagnostics.Experimental)]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("mcpMeta")]
    public JsonElement? McpMeta { get; set; }

    /// <summary>Model identifier that generated this tool call.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("model")]
    public string? Model { get; set; }

    /// <summary>Tool call ID of the parent tool invocation when this event originates from a sub-agent.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
#if NET5_0_OR_GREATER
    [Obsolete("This member is deprecated and will be removed in a future version.", DiagnosticId = "GHCP001")]
#endif
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("parentToolCallId")]
    public string? ParentToolCallId { get; set; }

    /// <summary>Tool execution result on success.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("result")]
    public ToolExecutionCompleteResult? Result { get; set; }

    /// <summary>Per-request treatment/eligibility signal returned by the Copilot API in the `X-GitHub-Copilot-Request-TE` response header for the associated model call; `false` when the header was absent or unparseable.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("rte")]
    public bool? Rte { get; set; }

    /// <summary>Whether this tool execution ran inside a sandbox container.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("sandboxed")]
    public bool? Sandboxed { get; set; }

    /// <summary>Whether the tool execution completed successfully.</summary>
    [JsonPropertyName("success")]
    public required bool Success { get; set; }

    /// <summary>Unique identifier for the completed tool call.</summary>
    [JsonPropertyName("toolCallId")]
    public required string ToolCallId { get; set; }

    /// <summary>Tool definition metadata, present for MCP tools with MCP Apps support.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("toolDescription")]
    public ToolExecutionCompleteToolDescription? ToolDescription { get; set; }

    /// <summary>Tool-specific telemetry data (e.g., CodeQL check counts, grep match counts).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("toolTelemetry")]
    public IDictionary<string, JsonElement>? ToolTelemetry { get; set; }

    /// <summary>Identifier for the agent loop turn this tool was invoked in, matching the corresponding assistant.turn_start event.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("turnId")]
    public string? TurnId { get; set; }
}

/// <summary>Persisted generic client-side tool activations restored when a session resumes.</summary>
public sealed partial class ToolSearchActivatedData
{
    /// <summary>Tool-search strategy that activated the definitions.</summary>
    [JsonPropertyName("strategy")]
    public required string Strategy { get; set; }

    /// <summary>Names of tool definitions activated by this search invocation.</summary>
    [JsonPropertyName("toolNames")]
    public required string[] ToolNames { get; set; }
}

/// <summary>Skill invocation details including content, allowed tools, and plugin metadata.</summary>
public sealed partial class SkillInvokedData
{
    /// <summary>Tool names that should be auto-approved when this skill is active.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("allowedTools")]
    public string[]? AllowedTools { get; set; }

    /// <summary>Full content of the skill file, injected into the conversation for the model.</summary>
    [JsonPropertyName("content")]
    public required string Content { get; set; }

    /// <summary>Description of the skill from its SKILL.md frontmatter.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("description")]
    public string? Description { get; set; }

    /// <summary>Whether model invocation is disabled for this skill.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("disableModelInvocation")]
    public bool? DisableModelInvocation { get; set; }

    /// <summary>Model identifier active when the skill was invoked, when known.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("model")]
    public string? Model { get; set; }

    /// <summary>Name of the invoked skill.</summary>
    [JsonPropertyName("name")]
    public required string Name { get; set; }

    /// <summary>File path to the SKILL.md definition, or an empty string for an SDK-provided skill without a filesystem identity.</summary>
    [JsonPropertyName("path")]
    public required string Path { get; set; }

    /// <summary>Name of the plugin this skill originated from, when applicable.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("pluginName")]
    public string? PluginName { get; set; }

    /// <summary>Version of the plugin this skill originated from, when applicable.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("pluginVersion")]
    public string? PluginVersion { get; set; }

    /// <summary>Source identifier for where the skill was discovered. Known values include: project (workspace skill), inherited (parent-directory skill), personal-copilot (~/.copilot/skills), personal-agents (~/.agents/skills), custom (configured directory), plugin (installed plugin), builtin (bundled runtime skill), remote (org/enterprise skill), and sdk (SDK-provided skill).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("source")]
    public string? Source { get; set; }

    /// <summary>What triggered the skill invocation: `user-invoked` (explicit user action, such as via a slash command or UI affordance), `agent-invoked` (agent requested the skill), or `context-load` (loaded as part of another context, such as preloading skills configured on a custom agent or subagent).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("trigger")]
    public SkillInvokedTrigger? Trigger { get; set; }
}

/// <summary>Payload of `sandbox.decision`, a bounded governance record of what the process sandbox was configured to do and whether it took effect. Discriminated by `kind`.</summary>
public sealed partial class SandboxDecisionData { }

/// <summary>Sub-agent startup details including parent tool call and agent information.</summary>
public sealed partial class SubagentStartedData
{
    /// <summary>Description of what the sub-agent does.</summary>
    [JsonPropertyName("agentDescription")]
    public required string AgentDescription { get; set; }

    /// <summary>Human-readable display name of the sub-agent.</summary>
    [JsonPropertyName("agentDisplayName")]
    public required string AgentDisplayName { get; set; }

    /// <summary>Internal name of the sub-agent.</summary>
    [JsonPropertyName("agentName")]
    public required string AgentName { get; set; }

    /// <summary>Type of the sub-agent selected at spawn time.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("agentType")]
    public string? AgentType { get; set; }

    /// <summary>Whether the sub-agent runs synchronously or in the background.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("executionMode")]
    public string? ExecutionMode { get; set; }

    /// <summary>Root id of the factory run that spawned this sub-agent, when it was spawned by one.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("factoryRunId")]
    public string? FactoryRunId { get; set; }

    /// <summary>Model the sub-agent will run with, when known at start.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("model")]
    public string? Model { get; set; }

    /// <summary>Task-registry ID of the spawning sub-agent. Absent when the root session spawned this child.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("parentId")]
    public string? ParentId { get; set; }

    /// <summary>Whether this sub-agent can be resumed. Currently always false.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("resumable")]
    public bool? Resumable { get; set; }

    /// <summary>Tool call ID of the parent tool invocation that spawned this sub-agent.</summary>
    [JsonPropertyName("toolCallId")]
    public required string ToolCallId { get; set; }
}

/// <summary>Resolved runtime configuration for a configured sub-agent.</summary>
public sealed partial class SubagentConfiguredData
{
    /// <summary>Resolved context tier, when configured for the model.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("contextTier")]
    public string? ContextTier { get; set; }

    /// <summary>Resolved model the sub-agent will run with.</summary>
    [JsonPropertyName("model")]
    public required string Model { get; set; }

    /// <summary>Whether the sub-agent accepts follow-up turns.</summary>
    [JsonPropertyName("multiTurn")]
    public required bool MultiTurn { get; set; }

    /// <summary>Resolved reasoning effort, when configured for the model.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("reasoningEffort")]
    public string? ReasoningEffort { get; set; }
}

/// <summary>Sub-agent completion details for successful execution.</summary>
public sealed partial class SubagentCompletedData
{
    /// <summary>Human-readable display name of the sub-agent.</summary>
    [JsonPropertyName("agentDisplayName")]
    public required string AgentDisplayName { get; set; }

    /// <summary>Internal name of the sub-agent.</summary>
    [JsonPropertyName("agentName")]
    public required string AgentName { get; set; }

    /// <summary>Whether the sub-agent was torn down by cancellation - its own abort, or an ancestor being killed - instead of finishing its work. Cancellation is not a failure, so the run still reports completion; this distinguishes a torn-down sub-agent from one that ran to the end.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("cancelled")]
    public bool? Cancelled { get; set; }

    /// <summary>Whether the first model actually dispatched matched the user's configured preference.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("configuredModelMatchesActual")]
    public bool? ConfiguredModelMatchesActual { get; set; }

    /// <summary>Concrete model the user configured for this sub-agent via `/subagents`, when present.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("configuredModelPreference")]
    public string? ConfiguredModelPreference { get; set; }

    /// <summary>Wall-clock duration of the sub-agent execution in milliseconds.</summary>
    [JsonConverter(typeof(MillisecondsTimeSpanConverter))]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("durationMs")]
    public TimeSpan? Duration { get; set; }

    /// <summary>Whether the explicit task-call model matched the user's configured preference.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("explicitModelMatchesPreference")]
    public bool? ExplicitModelMatchesPreference { get; set; }

    /// <summary>Explicit model supplied by the parent agent on the task call, when present.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("explicitModelOverride")]
    public string? ExplicitModelOverride { get; set; }

    /// <summary>First model for which the sub-agent started an inference request, when one was dispatched.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("firstDispatchedModel")]
    public string? FirstDispatchedModel { get; set; }

    /// <summary>Model used by the sub-agent.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("model")]
    public string? Model { get; set; }

    /// <summary>Why an explicit task-call model did not become the effective model.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("modelOverrideReason")]
    public string? ModelOverrideReason { get; set; }

    /// <summary>Tool call ID of the parent tool invocation that spawned this sub-agent.</summary>
    [JsonPropertyName("toolCallId")]
    public required string ToolCallId { get; set; }

    /// <summary>Total tokens (input + output) consumed by the sub-agent.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("totalTokens")]
    public long? TotalTokens { get; set; }

    /// <summary>Total number of tool calls made by the sub-agent.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("totalToolCalls")]
    public long? TotalToolCalls { get; set; }
}

/// <summary>Sub-agent failure details including error message and agent information.</summary>
public sealed partial class SubagentFailedData
{
    /// <summary>Human-readable display name of the sub-agent.</summary>
    [JsonPropertyName("agentDisplayName")]
    public required string AgentDisplayName { get; set; }

    /// <summary>Internal name of the sub-agent.</summary>
    [JsonPropertyName("agentName")]
    public required string AgentName { get; set; }

    /// <summary>Whether the first model actually dispatched matched the user's configured preference.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("configuredModelMatchesActual")]
    public bool? ConfiguredModelMatchesActual { get; set; }

    /// <summary>Concrete model the user configured for this sub-agent via `/subagents`, when present.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("configuredModelPreference")]
    public string? ConfiguredModelPreference { get; set; }

    /// <summary>Wall-clock duration of the sub-agent execution in milliseconds.</summary>
    [JsonConverter(typeof(MillisecondsTimeSpanConverter))]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("durationMs")]
    public TimeSpan? Duration { get; set; }

    /// <summary>Error message describing why the sub-agent failed.</summary>
    [JsonPropertyName("error")]
    public required string Error { get; set; }

    /// <summary>Whether the explicit task-call model matched the user's configured preference.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("explicitModelMatchesPreference")]
    public bool? ExplicitModelMatchesPreference { get; set; }

    /// <summary>Explicit model supplied by the parent agent on the task call, when present.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("explicitModelOverride")]
    public string? ExplicitModelOverride { get; set; }

    /// <summary>First model for which the sub-agent started an inference request, when one was dispatched.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("firstDispatchedModel")]
    public string? FirstDispatchedModel { get; set; }

    /// <summary>Model selected for the sub-agent, when known.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("model")]
    public string? Model { get; set; }

    /// <summary>Why an explicit task-call model did not become the effective model.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("modelOverrideReason")]
    public string? ModelOverrideReason { get; set; }

    /// <summary>Tool call ID of the parent tool invocation that spawned this sub-agent.</summary>
    [JsonPropertyName("toolCallId")]
    public required string ToolCallId { get; set; }

    /// <summary>Total tokens (input + output) consumed before the sub-agent failed.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("totalTokens")]
    public long? TotalTokens { get; set; }

    /// <summary>Total number of tool calls made before the sub-agent failed.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("totalToolCalls")]
    public long? TotalToolCalls { get; set; }
}

/// <summary>Custom agent selection details including name and available tools.</summary>
public sealed partial class SubagentSelectedData
{
    /// <summary>Human-readable display name of the selected custom agent.</summary>
    [JsonPropertyName("agentDisplayName")]
    public required string AgentDisplayName { get; set; }

    /// <summary>Internal name of the selected custom agent.</summary>
    [JsonPropertyName("agentName")]
    public required string AgentName { get; set; }

    /// <summary>List of tool names available to this agent, or null for all tools.</summary>
    [JsonPropertyName("tools")]
    public string[]? Tools { get; set; }
}

/// <summary>Empty payload; the event signals that the custom agent was deselected, returning to the default agent.</summary>
public sealed partial class SubagentDeselectedData
{
}

/// <summary>Hook invocation start details including type and input data.</summary>
public sealed partial class HookStartData
{
    /// <summary>Unique identifier for this hook invocation.</summary>
    [JsonPropertyName("hookInvocationId")]
    public required string HookInvocationId { get; set; }

    /// <summary>Type of hook being invoked (e.g., "preToolUse", "postToolUse", "sessionStart").</summary>
    [JsonPropertyName("hookType")]
    public required string HookType { get; set; }

    /// <summary>Input data passed to the hook. For postToolUse hooks the retained copy served by session.eventLog.read (and by a resumed session) elides the tool result's inline `contents`/`uiResource` and replaces an over-long `textResultForLlm` with a `[copilot:elided ...]` marker, to keep a multi-megabyte payload out of the durable event log; the live subscription stream still delivers the full value. Read the adjacent tool.execution_complete event for the tool result itself.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("input")]
    public JsonElement? Input { get; set; }

    /// <summary>Tool call ID of the parent tool invocation when this event originates from a sub-agent.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("parentToolCallId")]
    public string? ParentToolCallId { get; set; }
}

/// <summary>Hook invocation completion details including output, success status, and error information.</summary>
public sealed partial class HookEndData
{
    /// <summary>Error details when the hook failed.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("error")]
    public HookEndError? Error { get; set; }

    /// <summary>Identifier matching the corresponding hook.start event.</summary>
    [JsonPropertyName("hookInvocationId")]
    public required string HookInvocationId { get; set; }

    /// <summary>Type of hook that was invoked (e.g., "preToolUse", "postToolUse", "sessionStart").</summary>
    [JsonPropertyName("hookType")]
    public required string HookType { get; set; }

    /// <summary>Output data produced by the hook.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("output")]
    public JsonElement? Output { get; set; }

    /// <summary>Tool call ID of the parent tool invocation when this event originates from a sub-agent.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("parentToolCallId")]
    public string? ParentToolCallId { get; set; }

    /// <summary>Whether the hook completed successfully.</summary>
    [JsonPropertyName("success")]
    public required bool Success { get; set; }
}

/// <summary>Ephemeral progress update from a running hook process.</summary>
public sealed partial class HookProgressData
{
    /// <summary>Human-readable progress message from the hook process.</summary>
    [JsonPropertyName("message")]
    public required string Message { get; set; }

    /// <summary>When true, this status message replaces the previous temporary one instead of accumulating.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("temporary")]
    public bool? Temporary { get; set; }
}

/// <summary>Canonical bytes for a content-addressed binary asset shared by reference across events.</summary>
public sealed partial class SessionBinaryAssetData
{
    /// <summary>Content-addressed id for this binary asset (e.g. "sha256:...").</summary>
    [JsonPropertyName("assetId")]
    public required string AssetId { get; set; }

    /// <summary>Decoded byte length of the binary asset.</summary>
    [JsonPropertyName("byteLength")]
    public required long ByteLength { get; set; }

    /// <summary>Base64-encoded binary data.</summary>
    [Base64String]
    [JsonPropertyName("data")]
    public required string Data { get; set; }

    /// <summary>Human-readable description of the binary data.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("description")]
    public string? Description { get; set; }

    /// <summary>Optional metadata from the producing tool.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("metadata")]
    public IDictionary<string, JsonElement>? Metadata { get; set; }

    /// <summary>MIME type of the binary asset.</summary>
    [JsonPropertyName("mimeType")]
    public required string MimeType { get; set; }

    /// <summary>Binary asset type discriminator. Use "image" for images and "resource" otherwise.</summary>
    [JsonPropertyName("type")]
    public required BinaryAssetType Type { get; set; }
}

/// <summary>System/developer instruction content with role and optional template metadata.</summary>
public sealed partial class SystemMessageData
{
    /// <summary>The system or developer prompt text sent as model input.</summary>
    [JsonPropertyName("content")]
    public required string Content { get; set; }

    /// <summary>Logical interaction identifier for the model run receiving this prompt.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("interactionId")]
    public string? InteractionId { get; set; }

    /// <summary>Metadata about the prompt template and its construction.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("metadata")]
    public SystemMessageMetadata? Metadata { get; set; }

    /// <summary>Optional name identifier for the message source.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("name")]
    public string? Name { get; set; }

    /// <summary>Message role: "system" for system prompts, "developer" for developer-injected instructions.</summary>
    [JsonPropertyName("role")]
    public required SystemMessageRole Role { get; set; }
}

/// <summary>System-generated notification for runtime events like background task completion.</summary>
public sealed partial class SystemNotificationData
{
    /// <summary>The notification text, typically wrapped in &lt;system_notification&gt; XML tags.</summary>
    [JsonPropertyName("content")]
    public required string Content { get; set; }

    /// <summary>Structured metadata identifying what triggered this notification.</summary>
    [JsonPropertyName("kind")]
    public required SystemNotification Kind { get; set; }
}

/// <summary>Permission request notification requiring client approval with request details.</summary>
public sealed partial class PermissionRequestedData
{
    /// <summary>Agent mode captured from the owning turn when permission evaluation began.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("agentMode")]
    public SessionMode? AgentMode { get; set; }

    /// <summary>Details of the permission being requested.</summary>
    [JsonPropertyName("permissionRequest")]
    public required PermissionRequest PermissionRequest { get; set; }

    /// <summary>Derived user-facing permission prompt details for UI consumers.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("promptRequest")]
    public PermissionPromptRequest? PromptRequest { get; set; }

    /// <summary>Unique identifier for this permission request; used to respond via session.respondToPermission().</summary>
    [JsonPropertyName("requestId")]
    public required string RequestId { get; set; }

    /// <summary>When true, this permission was already resolved by a permissionRequest hook and requires no client action.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("resolvedByHook")]
    public bool? ResolvedByHook { get; set; }

    /// <summary>Neutral risk metadata supplied by the tool host. Consumers may display this value but must not use it to bypass the permission decision.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("riskAssessment")]
    public JsonElement? RiskAssessment { get; set; }
}

/// <summary>Permission request completion notification signaling UI dismissal.</summary>
public sealed partial class PermissionCompletedData
{
    /// <summary>Request ID of the resolved permission request; clients should dismiss any UI for this request.</summary>
    [JsonPropertyName("requestId")]
    public required string RequestId { get; set; }

    /// <summary>The result of the permission request.</summary>
    [JsonPropertyName("result")]
    public required PermissionResult Result { get; set; }

    /// <summary>Optional tool call ID associated with this permission prompt; clients may use it to correlate UI created from tool-scoped prompts.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("toolCallId")]
    public string? ToolCallId { get; set; }
}

/// <summary>User input request notification with question and optional predefined choices.</summary>
public sealed partial class UserInputRequestedData
{
    /// <summary>Whether the user can provide a free-form text response in addition to predefined choices.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("allowFreeform")]
    public bool? AllowFreeform { get; set; }

    /// <summary>Predefined choices for the user to select from, if applicable.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("choices")]
    public string[]? Choices { get; set; }

    /// <summary>The question or prompt to present to the user.</summary>
    [JsonPropertyName("question")]
    public required string Question { get; set; }

    /// <summary>Unique identifier for this input request; used to respond via session.respondToUserInput().</summary>
    [JsonPropertyName("requestId")]
    public required string RequestId { get; set; }

    /// <summary>The LLM-assigned tool call ID that triggered this request; used by remote UIs to correlate responses.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("toolCallId")]
    public string? ToolCallId { get; set; }
}

/// <summary>User input request completion with the user's response.</summary>
public sealed partial class UserInputCompletedData
{
    /// <summary>The user's answer to the input request.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("answer")]
    public string? Answer { get; set; }

    /// <summary>Request ID of the resolved user input request; clients should dismiss any UI for this request.</summary>
    [JsonPropertyName("requestId")]
    public required string RequestId { get; set; }

    /// <summary>Whether the answer was typed as free-form text rather than selected from choices.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("wasFreeform")]
    public bool? WasFreeform { get; set; }
}

/// <summary>Elicitation request; may be form-based (structured input) or URL-based (browser redirect).</summary>
public sealed partial class ElicitationRequestedData
{
    /// <summary>The source that initiated the request (MCP server name, or absent for agent-initiated).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("elicitationSource")]
    public string? ElicitationSource { get; set; }

    /// <summary>Message describing what information is needed from the user.</summary>
    [JsonPropertyName("message")]
    public required string Message { get; set; }

    /// <summary>Elicitation mode; "form" for structured input, "url" for browser-based. Defaults to "form" when absent.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("mode")]
    public ElicitationRequestedMode? Mode { get; set; }

    /// <summary>JSON Schema describing the form fields to present to the user (form mode only).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("requestedSchema")]
    public ElicitationRequestedSchema? RequestedSchema { get; set; }

    /// <summary>Unique identifier for this elicitation request; used to respond via session.respondToElicitation().</summary>
    [JsonPropertyName("requestId")]
    public required string RequestId { get; set; }

    /// <summary>Tool call ID from the LLM completion; used to correlate with CompletionChunk.toolCall.id for remote UIs.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("toolCallId")]
    public string? ToolCallId { get; set; }

    /// <summary>URL to open in the user's browser (url mode only).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("url")]
    public string? Url { get; set; }
}

/// <summary>Elicitation request completion with the user's response.</summary>
public sealed partial class ElicitationCompletedData
{
    /// <summary>The user action: "accept" (submitted form), "decline" (explicitly refused), or "cancel" (dismissed).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("action")]
    public ElicitationCompletedAction? Action { get; set; }

    /// <summary>The submitted form data when action is 'accept'; keys match the requested schema fields.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("content")]
    public IDictionary<string, JsonElement>? Content { get; set; }

    /// <summary>Request ID of the resolved elicitation request; clients should dismiss any UI for this request.</summary>
    [JsonPropertyName("requestId")]
    public required string RequestId { get; set; }
}

/// <summary>Sampling request from an MCP server; contains the server name and a requestId for correlation.</summary>
public sealed partial class SamplingRequestedData
{
    /// <summary>The JSON-RPC request ID from the MCP protocol.</summary>
    [JsonPropertyName("mcpRequestId")]
    public required JsonElement McpRequestId { get; set; }

    /// <summary>Unique identifier for this sampling request; used to respond via session.respondToSampling().</summary>
    [JsonPropertyName("requestId")]
    public required string RequestId { get; set; }

    /// <summary>Name of the MCP server that initiated the sampling request.</summary>
    [JsonPropertyName("serverName")]
    public required string ServerName { get; set; }
}

/// <summary>Sampling request completion notification signaling UI dismissal.</summary>
public sealed partial class SamplingCompletedData
{
    /// <summary>Request ID of the resolved sampling request; clients should dismiss any UI for this request.</summary>
    [JsonPropertyName("requestId")]
    public required string RequestId { get; set; }
}

/// <summary>OAuth authentication request for an MCP server.</summary>
public sealed partial class McpOauthRequiredData
{
    /// <summary>Raw HTTP response details from the OAuth auth challenge, as observed by the runtime. Header order and casing are transport-dependent, and duplicate header names may appear multiple times.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("httpResponse")]
    public McpOauthHttpResponse? HttpResponse { get; set; }

    /// <summary>Why the runtime is requesting host-provided OAuth credentials.</summary>
    [JsonPropertyName("reason")]
    public required McpOauthRequestReason Reason { get; set; }

    /// <summary>Unique identifier for this OAuth request; used to respond via session.mcp.oauth.handlePendingRequest.</summary>
    [JsonPropertyName("requestId")]
    public required string RequestId { get; set; }

    /// <summary>Raw OAuth protected-resource metadata document fetched for the MCP server, if available.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("resourceMetadata")]
    public string? ResourceMetadata { get; set; }

    /// <summary>Display name of the MCP server that requires OAuth.</summary>
    [JsonPropertyName("serverName")]
    public required string ServerName { get; set; }

    /// <summary>URL of the MCP server that requires OAuth.</summary>
    [JsonPropertyName("serverUrl")]
    public required string ServerUrl { get; set; }

    /// <summary>Static OAuth client configuration, if the server specifies one.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("staticClientConfig")]
    public McpOauthRequiredStaticClientConfig? StaticClientConfig { get; set; }

    /// <summary>OAuth WWW-Authenticate parameters parsed from the auth challenge, if available.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("wwwAuthenticateParams")]
    public McpOauthWWWAuthenticateParams? WwwAuthenticateParams { get; set; }
}

/// <summary>MCP OAuth request completion notification.</summary>
public sealed partial class McpOauthCompletedData
{
    /// <summary>How the pending OAuth request was completed.</summary>
    [JsonPropertyName("outcome")]
    public required McpOauthCompletionOutcome Outcome { get; set; }

    /// <summary>Request ID of the resolved OAuth request.</summary>
    [JsonPropertyName("requestId")]
    public required string RequestId { get; set; }
}

/// <summary>Dynamic headers refresh request for a remote MCP server.</summary>
public sealed partial class McpHeadersRefreshRequiredData
{
    /// <summary>Why dynamic headers are being requested.</summary>
    [JsonPropertyName("reason")]
    public required McpHeadersRefreshRequiredReason Reason { get; set; }

    /// <summary>Unique identifier for this headers refresh request; used to respond via session.mcp.headers.handlePendingHeadersRefreshRequest().</summary>
    [JsonPropertyName("requestId")]
    public required string RequestId { get; set; }

    /// <summary>Display name of the remote MCP server requesting headers.</summary>
    [JsonPropertyName("serverName")]
    public required string ServerName { get; set; }

    /// <summary>URL of the remote MCP server requesting headers.</summary>
    [JsonPropertyName("serverUrl")]
    public required string ServerUrl { get; set; }
}

/// <summary>MCP headers refresh request completion notification.</summary>
public sealed partial class McpHeadersRefreshCompletedData
{
    /// <summary>How the pending MCP headers refresh request resolved.</summary>
    [JsonPropertyName("outcome")]
    public required McpHeadersRefreshCompletedOutcome Outcome { get; set; }

    /// <summary>Request ID of the resolved headers refresh request.</summary>
    [JsonPropertyName("requestId")]
    public required string RequestId { get; set; }
}

/// <summary>Opaque custom notification data. Consumers may branch on source and name, but payload semantics are source-defined.</summary>
public sealed partial class SessionCustomNotificationData
{
    /// <summary>Source-defined custom notification name.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("name")]
    public required string Name { get; set; }

    /// <summary>Source-defined JSON payload for the custom notification.</summary>
    [JsonPropertyName("payload")]
    public required JsonElement Payload { get; set; }

    /// <summary>Namespace for the custom notification producer.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("source")]
    public required string Source { get; set; }

    /// <summary>Optional source-defined string identifiers describing the payload subject.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("subject")]
    public IDictionary<string, string>? Subject { get; set; }

    /// <summary>Optional source-defined payload schema version.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("version")]
    public long? Version { get; set; }
}

/// <summary>Ordered output and terminal state for a transient query that does not modify conversation history.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed partial class UiEphemeralQueryData
{
    /// <summary>Full response text, present for the `completed` phase.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("answer")]
    public string? Answer { get; set; }

    /// <summary>Ordered text delta, present for the `chunk` phase.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("chunk")]
    public string? Chunk { get; set; }

    /// <summary>Model or transport failure message, present for the `failed` phase.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("error")]
    public string? Error { get; set; }

    /// <summary>Current query lifecycle phase.</summary>
    [JsonPropertyName("phase")]
    public required UIEphemeralQueryPhase Phase { get; set; }

    /// <summary>Runtime-minted query identifier.</summary>
    [JsonPropertyName("requestId")]
    public required string RequestId { get; set; }
}

/// <summary>External tool invocation request for client-side tool execution.</summary>
public sealed partial class ExternalToolRequestedData
{
    /// <summary>Arguments to pass to the external tool.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("arguments")]
    public JsonElement? Arguments { get; set; }

    /// <summary>Stable provider identity captured with an extension-owned tool definition; hosts use it to route the request to the same provider that was offered to the model.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("providerId")]
    public string? ProviderId { get; set; }

    /// <summary>Unique identifier for this request; used to respond via session.respondToExternalTool().</summary>
    [JsonPropertyName("requestId")]
    public required string RequestId { get; set; }

    /// <summary>Session ID that this external tool request belongs to.</summary>
    [JsonPropertyName("sessionId")]
    public required string SessionId { get; set; }

    /// <summary>Tool call ID assigned to this external tool invocation.</summary>
    [JsonPropertyName("toolCallId")]
    public required string ToolCallId { get; set; }

    /// <summary>Name of the external tool to invoke.</summary>
    [JsonPropertyName("toolName")]
    public required string ToolName { get; set; }

    /// <summary>W3C Trace Context traceparent header for the execute_tool span.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("traceparent")]
    public string? Traceparent { get; set; }

    /// <summary>W3C Trace Context tracestate header for the execute_tool span.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("tracestate")]
    public string? Tracestate { get; set; }

    /// <summary>Active session working directory, when known.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("workingDirectory")]
    public string? WorkingDirectory { get; set; }
}

/// <summary>External tool completion notification signaling UI dismissal.</summary>
public sealed partial class ExternalToolCompletedData
{
    /// <summary>Request ID of the resolved external tool request; clients should dismiss any UI for this request.</summary>
    [JsonPropertyName("requestId")]
    public required string RequestId { get; set; }
}

/// <summary>Queued slash command dispatch request for client execution.</summary>
public sealed partial class CommandQueuedData
{
    /// <summary>The slash command text to be executed (e.g., /help, /clear).</summary>
    [JsonPropertyName("command")]
    public required string Command { get; set; }

    /// <summary>Unique identifier for this request; used to respond via session.respondToQueuedCommand().</summary>
    [JsonPropertyName("requestId")]
    public required string RequestId { get; set; }
}

/// <summary>Registered command dispatch request routed to the owning client.</summary>
public sealed partial class CommandExecuteData
{
    /// <summary>Raw argument string after the command name.</summary>
    [JsonPropertyName("args")]
    public required string Args { get; set; }

    /// <summary>The full command text (e.g., /deploy production).</summary>
    [JsonPropertyName("command")]
    public required string Command { get; set; }

    /// <summary>Command name without leading /.</summary>
    [JsonPropertyName("commandName")]
    public required string CommandName { get; set; }

    /// <summary>Unique identifier; used to respond via session.commands.handlePendingCommand().</summary>
    [JsonPropertyName("requestId")]
    public required string RequestId { get; set; }
}

/// <summary>Queued command completion notification signaling UI dismissal.</summary>
public sealed partial class CommandCompletedData
{
    /// <summary>Request ID of the resolved command request; clients should dismiss any UI for this request.</summary>
    [JsonPropertyName("requestId")]
    public required string RequestId { get; set; }
}

/// <summary>Auto mode switch request notification requiring user approval.</summary>
public sealed partial class AutoModeSwitchRequestedData
{
    /// <summary>The rate limit error code that triggered this request.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("errorCode")]
    public string? ErrorCode { get; set; }

    /// <summary>Unique identifier for this request; used to respond via session.respondToAutoModeSwitch().</summary>
    [JsonPropertyName("requestId")]
    public required string RequestId { get; set; }

    /// <summary>Seconds until the rate limit resets, when known. Lets clients render a humanized reset time alongside the prompt.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("retryAfterSeconds")]
    public long? RetryAfterSeconds { get; set; }
}

/// <summary>Auto mode switch completion notification.</summary>
public sealed partial class AutoModeSwitchCompletedData
{
    /// <summary>Request ID of the resolved request; clients should dismiss any UI for this request.</summary>
    [JsonPropertyName("requestId")]
    public required string RequestId { get; set; }

    /// <summary>The user's auto-mode-switch choice.</summary>
    [JsonPropertyName("response")]
    public required AutoModeSwitchResponse Response { get; set; }
}

/// <summary>Session limit exhaustion notification requiring user action.</summary>
public sealed partial class SessionLimitsExhaustedRequestedData
{
    /// <summary>Configured max AI Credits for the current accounting window.</summary>
    [JsonPropertyName("maxAiCredits")]
    public required double MaxAiCredits { get; set; }

    /// <summary>Unique identifier for this request; used to respond via session.ui.handlePendingSessionLimitsExhausted().</summary>
    [JsonPropertyName("requestId")]
    public required string RequestId { get; set; }

    /// <summary>AI Credits already consumed in the current accounting window.</summary>
    [JsonPropertyName("usedAiCredits")]
    public required double UsedAiCredits { get; set; }
}

/// <summary>Session limit exhaustion prompt completion notification.</summary>
public sealed partial class SessionLimitsExhaustedCompletedData
{
    /// <summary>Request ID of the resolved request; clients should dismiss any UI for this request.</summary>
    [JsonPropertyName("requestId")]
    public required string RequestId { get; set; }

    /// <summary>The user's selected session-limit action.</summary>
    [JsonPropertyName("response")]
    public required SessionLimitsExhaustedResponse Response { get; set; }
}

/// <summary>Auto Intent resolution: the concrete model the session settled on for the first prompt of an auto-mode session, and why. Lets SDK clients render the chosen model and the full reason it was picked. The core selection fields (chosenModel/reasoningBucket/categoryScores) are stable; the routing-analytics fields (predictedLabel/confidence/candidateModels) mirror the upstream intent service and may evolve, hence the event's experimental stability.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed partial class SessionAutoModeResolvedData
{
    /// <summary>Models offered to the router for this resolution.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("availableModels")]
    public string[]? AvailableModels { get; set; }

    /// <summary>Ordered candidate model list the router returned, when not a fallback.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("candidateModels")]
    public string[]? CandidateModels { get; set; }

    /// <summary>Per-category classifier scores (0-1) behind the bucket: the granular HYDRA capability scores (reasoning, code_gen, debugging, tool_use), or the binary needs_reasoning/no_reasoning scores when HYDRA didn't run. Lets clients show a breakdown rather than just the bucket.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("categoryScores")]
    public IDictionary<string, double>? CategoryScores { get; set; }

    /// <summary>The concrete model the session will use after any intent refinement.</summary>
    [JsonPropertyName("chosenModel")]
    public required string ChosenModel { get; set; }

    /// <summary>The chosen model's score shortfall relative to the top candidate.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("chosenShortfall")]
    public double? ChosenShortfall { get; set; }

    /// <summary>Classifier confidence for the predicted label, when available.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("confidence")]
    public double? Confidence { get; set; }

    /// <summary>End-to-end client wait time for the router request in milliseconds.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("endToEndLatencyMs")]
    public double? EndToEndLatencyMs { get; set; }

    /// <summary>Whether the router fell back to the standard Auto selection.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("fallback")]
    public bool? Fallback { get; set; }

    /// <summary>Server-provided reason for falling back, when available.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("fallbackReason")]
    public string? FallbackReason { get; set; }

    /// <summary>Whether the routed prompt contained an image.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("hasImage")]
    public bool? HasImage { get; set; }

    /// <summary>The predicted classifier label (e.g. `needs_reasoning`), when available.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("predictedLabel")]
    public string? PredictedLabel { get; set; }

    /// <summary>Coarse request-difficulty bucket, for explaining why a model was chosen ("picked X because this looks like high-reasoning work").</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("reasoningBucket")]
    public AutoModeResolvedReasoningBucket? ReasoningBucket { get; set; }

    /// <summary>Server-reported router processing time in milliseconds.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("routerLatencyMs")]
    public double? RouterLatencyMs { get; set; }

    /// <summary>The routing method the server applied, when Auto Intent ran.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("routingMethod")]
    public string? RoutingMethod { get; set; }

    /// <summary>Whether a sticky model choice overrode the router result.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("stickyOverride")]
    public bool? StickyOverride { get; set; }
}

/// <summary>Enterprise managed-settings resolution: the effective managed settings the session applied and which channels contributed, so SDK clients can show users what is enterprise-managed. Fires whenever managed policy is (re)applied — at session start, on resume, and on account switch. This is an ephemeral live snapshot (delivered to subscribers but not persisted to the session event log), because at session start it resolves before `session.start` is emitted. Device values take precedence over server values, then the policy helper, per ordinary key, while permissions compose restrictively across device, server, policy-helper, and SDK-client layers. The account-scoped `getManagedSettings()` API does not include session-local client injection. Marked experimental while the managed-settings surface stabilizes.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed partial class SessionManagedSettingsResolvedData
{
    /// <summary>Whether enterprise policy disables bypass-permissions ("yolo") mode for this session. Deny-wins across layers, and forced on when `failClosed` is true.</summary>
    [JsonPropertyName("bypassPermissionsDisabled")]
    public required bool BypassPermissionsDisabled { get; set; }

    /// <summary>Whether a session-local permissions layer injected by the SDK host was present.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("clientManaged")]
    public bool? ClientManaged { get; set; }

    /// <summary>Whether an actual device MDM/plist/registry/file managed-settings layer was present.</summary>
    [JsonPropertyName("deviceManaged")]
    public required bool DeviceManaged { get; set; }

    /// <summary>Whether managed policy could not be determined (e.g. a failed server fetch) and the session fell back to the fail-closed restriction. When true, restrictions such as disabling bypass-permissions are enforced even though `settings` may be absent.</summary>
    [JsonPropertyName("failClosed")]
    public required bool FailClosed { get; set; }

    /// <summary>The setting keys under enterprise management in the effective managed settings (e.g. `model`, `enabledPlugins`, `permissions`). Empty when no managed settings are in force.</summary>
    [JsonPropertyName("managedKeys")]
    public required string[] ManagedKeys { get; set; }

    /// <summary>Whether at least two managed sources supplied permission allowlists, so enforcement intersects them and the flattened settings payload omits `permissions.allow`.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("permissionsAllowIntersected")]
    public bool? PermissionsAllowIntersected { get; set; }

    /// <summary>Whether the policy-helper managed-settings layer was present. The policy helper is the weakest channel: it fills keys no enterprise source set and can never replace one.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("policyHelperManaged")]
    public bool? PolicyHelperManaged { get; set; }

    /// <summary>Whether the effective sandbox policy forces the sandbox on *only* because managed policy could not be determined, rather than because the policy requires it. Lets clients tell a user whose `--no-sandbox` was overridden that the sandbox stayed on as a fail-closed fallback, instead of attributing it to an administrator who set no such policy.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("sandboxEnabledByUndeterminedPolicy")]
    public bool? SandboxEnabledByUndeterminedPolicy { get; set; }

    /// <summary>Whether the server (account/org) managed-settings layer was present.</summary>
    [JsonPropertyName("serverManaged")]
    public required bool ServerManaged { get; set; }

    /// <summary>The effective (resolved) managed settings values, so clients can render exactly what is enforced. Absent when no managed policy is in force.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("settings")]
    public JsonElement? Settings { get; set; }

    /// <summary>Channel summary: `server`, `device`, `client`, or `policyHelper` when exactly one channel contributed; `mixed` when multiple channels contributed; otherwise `none`. Consult the per-channel booleans for exact provenance.</summary>
    [JsonPropertyName("source")]
    public required ManagedSettingsResolvedSource Source { get; set; }
}

/// <summary>Runtime enforcement of enterprise managed settings: fires when the session blocks or caps a runtime action because enterprise policy governs it, so SDK clients can explain *why* an action was governed. Unlike `session.managed_settings_resolved` (which reports *what* is managed), this reports a concrete governed action — e.g. a user or host tried to turn on a bypass-permissions escalation while policy disables it. Emitted live (not persisted to the session event log) on user/host-initiated attempts only, never for silent policy application. Marked experimental while the managed-settings surface stabilizes.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed partial class SessionManagedSettingsEnforcedData
{
    /// <summary>The category of runtime action that managed policy governed.</summary>
    [JsonPropertyName("action")]
    public required ManagedSettingsEnforcedAction Action { get; set; }

    /// <summary>For a `bypass_permissions_blocked` action, which permission-escalation primitive was refused. Absent for actions without a specific escalation primitive.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("escalation")]
    public ManagedSettingsEnforcedEscalation? Escalation { get; set; }

    /// <summary>Whether the enforcement was forced by fail-closed handling (managed policy could not be determined) rather than an explicit managed setting. When true, `setting` still names the restriction that was applied.</summary>
    [JsonPropertyName("failClosed")]
    public required bool FailClosed { get; set; }

    /// <summary>A human-readable explanation of why the action was governed, suitable for surfacing to the user.</summary>
    [JsonPropertyName("message")]
    public required string Message { get; set; }

    /// <summary>The managed setting key responsible for the enforcement (e.g. `permissions.disableBypassPermissionsMode`).</summary>
    [JsonPropertyName("setting")]
    public required string Setting { get; set; }
}

/// <summary>SDK command registration change notification.</summary>
public sealed partial class CommandsChangedData
{
    /// <summary>Current list of registered SDK commands.</summary>
    [JsonPropertyName("commands")]
    public required CommandsChangedCommand[] Commands { get; set; }
}

/// <summary>Session capability change notification.</summary>
public sealed partial class CapabilitiesChangedData
{
    /// <summary>UI capability changes.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("ui")]
    public CapabilitiesChangedUI? Ui { get; set; }
}

/// <summary>Plan approval request with plan content and available user actions.</summary>
public sealed partial class ExitPlanModeRequestedData
{
    /// <summary>Available actions the user can take.</summary>
    [JsonPropertyName("actions")]
    public required ExitPlanModeAction[] Actions { get; set; }

    /// <summary>Model the session had selected when the plan was authored, when one is known.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("model")]
    public string? Model { get; set; }

    /// <summary>Full content of the plan file.</summary>
    [JsonPropertyName("planContent")]
    public required string PlanContent { get; set; }

    /// <summary>Recommended action to preselect for the user.</summary>
    [JsonPropertyName("recommendedAction")]
    public required ExitPlanModeAction RecommendedAction { get; set; }

    /// <summary>Unique identifier for this request; used to respond via session.respondToExitPlanMode().</summary>
    [JsonPropertyName("requestId")]
    public required string RequestId { get; set; }

    /// <summary>Summary of the plan that was created.</summary>
    [JsonPropertyName("summary")]
    public required string Summary { get; set; }
}

/// <summary>Plan mode exit completion with the user's approval decision and optional feedback.</summary>
public sealed partial class ExitPlanModeCompletedData
{
    /// <summary>Whether the plan was approved by the user.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("approved")]
    public bool? Approved { get; set; }

    /// <summary>Whether edits should be auto-approved without confirmation.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("autoApproveEdits")]
    public bool? AutoApproveEdits { get; set; }

    /// <summary>Free-form feedback from the user if they requested changes to the plan.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("feedback")]
    public string? Feedback { get; set; }

    /// <summary>Request ID of the resolved exit plan mode request; clients should dismiss any UI for this request.</summary>
    [JsonPropertyName("requestId")]
    public required string RequestId { get; set; }

    /// <summary>Action selected by the user.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("selectedAction")]
    public ExitPlanModeAction? SelectedAction { get; set; }
}

/// <summary>Payload of `session.tools_updated` identifying the model whose resolved tools were updated.</summary>
public sealed partial class SessionToolsUpdatedData
{
    /// <summary>Identifier of the model the resolved tools apply to.</summary>
    [JsonPropertyName("model")]
    public required string Model { get; set; }
}

/// <summary>Empty payload for `session.background_tasks_changed`, indicating background task state changed.</summary>
public sealed partial class SessionBackgroundTasksChangedData
{
}

/// <summary>Ephemeral invalidation signal for a changed factory run.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed partial class FactoryRunUpdatedData
{
    /// <summary>Monotonic revision now available for the run.</summary>
    [JsonPropertyName("revision")]
    public required long Revision { get; set; }

    /// <summary>Factory run identifier.</summary>
    [JsonPropertyName("runId")]
    public required string RunId { get; set; }
}

/// <summary>Ephemeral signal that a factory run attempt began executing.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed partial class FactoryRunStartedData
{
    /// <summary>Attempt number this start committed; a resumed run increments it.</summary>
    [JsonPropertyName("attempt")]
    public required long Attempt { get; set; }

    /// <summary>Name of the factory this run executes. Low cardinality by construction.</summary>
    [JsonPropertyName("factoryName")]
    public required string FactoryName { get; set; }

    /// <summary>Identifier of the factory run that started.</summary>
    [JsonPropertyName("runId")]
    public required string RunId { get; set; }
}

/// <summary>Ephemeral signal that a factory run reached a terminal status.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed partial class FactoryRunSettledData
{
    /// <summary>AI credits this run consumed, in nano-AIU.</summary>
    [JsonPropertyName("consumedNanoAiu")]
    public required long ConsumedNanoAiu { get; set; }

    /// <summary>Subagents this run consumed against its limits.</summary>
    [JsonPropertyName("consumedSubagents")]
    public required long ConsumedSubagents { get; set; }

    /// <summary>Active milliseconds accumulated across every attempt of this run.</summary>
    [JsonPropertyName("elapsedMs")]
    public required long ElapsedMs { get; set; }

    /// <summary>Typed failure class recorded on the run, when it failed with one (e.g. `factory_limit_reached`).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("failureType")]
    public string? FailureType { get; set; }

    /// <summary>Identifier of the factory run that settled.</summary>
    [JsonPropertyName("runId")]
    public required string RunId { get; set; }

    /// <summary>Terminal status the run committed.</summary>
    [JsonPropertyName("status")]
    public required FactoryRunSettledStatus Status { get; set; }
}

/// <summary>Payload of `session.skills_loaded` listing resolved skill metadata.</summary>
public sealed partial class SessionSkillsLoadedData
{
    /// <summary>Array of resolved skill metadata.</summary>
    [JsonPropertyName("skills")]
    public required SkillsLoadedSkill[] Skills { get; set; }
}

/// <summary>Payload of `session.custom_agents_updated` with loaded custom agents plus non-fatal warnings and fatal errors.</summary>
public sealed partial class SessionCustomAgentsUpdatedData
{
    /// <summary>Array of loaded custom agent metadata.</summary>
    [JsonPropertyName("agents")]
    public required CustomAgentsUpdatedAgent[] Agents { get; set; }

    /// <summary>Fatal errors from agent loading.</summary>
    [JsonPropertyName("errors")]
    public required string[] Errors { get; set; }

    /// <summary>Non-fatal warnings from agent loading.</summary>
    [JsonPropertyName("warnings")]
    public required string[] Warnings { get; set; }
}

/// <summary>Payload of `session.mcp_servers_loaded` listing MCP server status summaries.</summary>
public sealed partial class SessionMcpServersLoadedData
{
    /// <summary>Array of MCP server status summaries.</summary>
    [JsonPropertyName("servers")]
    public required McpServersLoadedServer[] Servers { get; set; }
}

/// <summary>Payload of `session.mcp_server_status_changed` for one MCP server's status and optional failure error.</summary>
public sealed partial class SessionMcpServerStatusChangedData
{
    /// <summary>Error message if the server entered a failed state.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("error")]
    public string? Error { get; set; }

    /// <summary>Name of the MCP server whose status changed.</summary>
    [JsonPropertyName("serverName")]
    public required string ServerName { get; set; }

    /// <summary>Connection status: connected, failed, needs-auth, pending, disabled, stopped, or not_configured.</summary>
    [JsonPropertyName("status")]
    public required McpServerStatus Status { get; set; }
}

/// <summary>Payload of `session.mcp_server_removed` identifying an MCP server the graph no longer runs.</summary>
public sealed partial class SessionMcpServerRemovedData
{
    /// <summary>Name of the MCP server that was removed from the graph.</summary>
    [JsonPropertyName("serverName")]
    public required string ServerName { get; set; }
}

/// <summary>Payload of `session.mcp_server_needs_reconnect` identifying an MCP server whose connection must be re-established.</summary>
public sealed partial class SessionMcpServerNeedsReconnectData
{
    /// <summary>Name of the MCP server that needs to reconnect.</summary>
    [JsonPropertyName("serverName")]
    public required string ServerName { get; set; }
}

/// <summary>Payload identifying the MCP server associated with a list change.</summary>
public sealed partial class McpToolsListChangedData
{
    /// <summary>Name of the MCP server whose list changed.</summary>
    [JsonPropertyName("serverName")]
    public required string ServerName { get; set; }
}

/// <summary>Payload identifying the MCP server associated with a list change.</summary>
public sealed partial class McpResourcesListChangedData
{
    /// <summary>Name of the MCP server whose list changed.</summary>
    [JsonPropertyName("serverName")]
    public required string ServerName { get; set; }
}

/// <summary>Payload identifying the MCP server associated with a list change.</summary>
public sealed partial class McpPromptsListChangedData
{
    /// <summary>Name of the MCP server whose list changed.</summary>
    [JsonPropertyName("serverName")]
    public required string ServerName { get; set; }
}

/// <summary>Payload of `session.extensions_loaded` listing discovered extensions and their statuses.</summary>
public sealed partial class SessionExtensionsLoadedData
{
    /// <summary>Array of discovered extensions and their status.</summary>
    [JsonPropertyName("extensions")]
    public required ExtensionsLoadedExtension[] Extensions { get; set; }
}

/// <summary>Payload of `session.canvas.opened` with canvas instance and provider IDs plus optional icon, title, status, URL, and input.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed partial class SessionCanvasOpenedData
{
    /// <summary>Provider-local canvas identifier.</summary>
    [JsonPropertyName("canvasId")]
    public required string CanvasId { get; set; }

    /// <summary>Owning provider identifier.</summary>
    [JsonPropertyName("extensionId")]
    public required string ExtensionId { get; set; }

    /// <summary>Owning extension display name, when available.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("extensionName")]
    public string? ExtensionName { get; set; }

    /// <summary>Host-local PNG path for the canvas icon, when supplied.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("icon")]
    public string? Icon { get; set; }

    /// <summary>Input supplied when the instance was opened.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("input")]
    public JsonElement? Input { get; set; }

    /// <summary>Stable caller-supplied canvas instance identifier.</summary>
    [JsonPropertyName("instanceId")]
    public required string InstanceId { get; set; }

    /// <summary>Provider-supplied status text.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("status")]
    public string? Status { get; set; }

    /// <summary>Rendered title.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("title")]
    public string? Title { get; set; }

    /// <summary>URL for web-rendered canvases.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("url")]
    public string? Url { get; set; }
}

/// <summary>Payload of `session.canvas.registry_changed` listing the canvas declarations currently available.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed partial class SessionCanvasRegistryChangedData
{
    /// <summary>Canvas declarations currently available.</summary>
    [JsonPropertyName("canvases")]
    public required CanvasRegistryChangedCanvas[] Canvases { get; set; }
}

/// <summary>Payload of `session.canvas.closed` with the closed canvas instance ID, provider ID, and canvas ID.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed partial class SessionCanvasClosedData
{
    /// <summary>Provider-local canvas identifier.</summary>
    [JsonPropertyName("canvasId")]
    public required string CanvasId { get; set; }

    /// <summary>Owning provider identifier.</summary>
    [JsonPropertyName("extensionId")]
    public required string ExtensionId { get; set; }

    /// <summary>Stable caller-supplied identifier of the canvas instance that was closed.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("instanceId")]
    public required string InstanceId { get; set; }
}

/// <summary>Transient signal that an open canvas instance's provider has dropped (for example the extension is reloading mid-session). The host should keep the panel mounted and surface a reconnecting affordance rather than tearing it down; a subsequent `session.canvas.opened` for the same instanceId clears the affordance once the provider reconnects with a fresh url. Ephemeral and never persisted, so it is never replayed on cold resume.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed partial class SessionCanvasUnavailableData
{
    /// <summary>Provider-local canvas identifier.</summary>
    [JsonPropertyName("canvasId")]
    public required string CanvasId { get; set; }

    /// <summary>Owning provider identifier.</summary>
    [JsonPropertyName("extensionId")]
    public required string ExtensionId { get; set; }

    /// <summary>Stable caller-supplied identifier of the canvas instance whose provider became unavailable.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("instanceId")]
    public required string InstanceId { get; set; }
}

/// <summary>Durable record that a canvas instance is open, used to restore open canvases on cold session resume. Intentionally omits the transient url and availability.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed partial class SessionCanvasRecordedData
{
    /// <summary>Provider-local canvas identifier.</summary>
    [JsonPropertyName("canvasId")]
    public required string CanvasId { get; set; }

    /// <summary>Owning provider identifier.</summary>
    [JsonPropertyName("extensionId")]
    public required string ExtensionId { get; set; }

    /// <summary>Input supplied when the instance was opened.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("input")]
    public JsonElement? Input { get; set; }

    /// <summary>Stable caller-supplied canvas instance identifier.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("instanceId")]
    public required string InstanceId { get; set; }

    /// <summary>Rendered title.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("title")]
    public string? Title { get; set; }
}

/// <summary>Durable record that a canvas instance was closed, superseding a prior instance_recorded during resume replay.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed partial class SessionCanvasRemovedData
{
    /// <summary>Provider-local canvas identifier.</summary>
    [JsonPropertyName("canvasId")]
    public required string CanvasId { get; set; }

    /// <summary>Owning provider identifier.</summary>
    [JsonPropertyName("extensionId")]
    public required string ExtensionId { get; set; }

    /// <summary>Stable caller-supplied identifier of the canvas instance that was closed.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("instanceId")]
    public required string InstanceId { get; set; }
}

/// <summary>Payload of `session.extensions.attachments_pushed` with extension-contributed attachments for the next send.</summary>
public sealed partial class SessionExtensionsAttachmentsPushedData
{
    /// <summary>Attachments contributed by an extension; the host should surface these as composer pills and forward them via the next session.send call.</summary>
    [JsonPropertyName("attachments")]
    public required Attachment[] Attachments { get; set; }
}

/// <summary>MCP App view called a tool on a connected MCP server (SEP-1865).</summary>
public sealed partial class McpAppToolCallCompleteData
{
    /// <summary>Arguments passed to the tool by the app view, if any.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("arguments")]
    public IDictionary<string, JsonElement>? Arguments { get; set; }

    /// <summary>Wall-clock duration of the underlying tools/call in milliseconds.</summary>
    [JsonPropertyName("durationMs")]
    public required double DurationMs { get; set; }

    /// <summary>Set when the underlying tools/call threw an error before returning a CallToolResult.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("error")]
    public McpAppToolCallCompleteError? Error { get; set; }

    /// <summary>Standard MCP CallToolResult returned by the server. Present whether or not the call set isError.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("result")]
    public IDictionary<string, JsonElement>? Result { get; set; }

    /// <summary>Name of the MCP server hosting the tool.</summary>
    [JsonPropertyName("serverName")]
    public required string ServerName { get; set; }

    /// <summary>True when the call completed without throwing AND the MCP CallToolResult did not set isError.</summary>
    [JsonPropertyName("success")]
    public required bool Success { get; set; }

    /// <summary>The tool's `_meta.ui` block at the time of the call, so consumers can decide whether to forward the result to the model without re-listing tools.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("toolMeta")]
    public McpAppToolCallCompleteToolMeta? ToolMeta { get; set; }

    /// <summary>MCP tool name that was invoked.</summary>
    [JsonPropertyName("toolName")]
    public required string ToolName { get; set; }
}

/// <summary>Working directory and git context at session start.</summary>
/// <remarks>Nested data type for <c>WorkingDirectoryContext</c>.</remarks>
public sealed partial class WorkingDirectoryContext
{
    /// <summary>Base commit of current git branch at session start time.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("baseCommit")]
    public string? BaseCommit { get; set; }

    /// <summary>Current git branch name.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("branch")]
    public string? Branch { get; set; }

    /// <summary>Current working directory path.</summary>
    [JsonPropertyName("cwd")]
    public required string Cwd { get; set; }

    /// <summary>Root directory of the git repository, resolved via git rev-parse.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("gitRoot")]
    public string? GitRoot { get; set; }

    /// <summary>Head commit of current git branch at session start time.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("headCommit")]
    public string? HeadCommit { get; set; }

    /// <summary>Hosting platform type of the repository (github or ado).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("hostType")]
    public WorkingDirectoryContextHostType? HostType { get; set; }

    /// <summary>Set on the immediate preliminary event of a working-directory change, before the git context is resolved. A settled follow-up event (enriched with git context, or cwd-only for a non-repository) is always emitted afterward, so observers may defer to it. Absent on standalone/final events (e.g. relay context changes).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("pendingGitContext")]
    public bool? PendingGitContext { get; set; }

    /// <summary>Repository identifier derived from the git remote URL ("owner/name" for GitHub, "org/project/repo" for Azure DevOps).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("repository")]
    public string? Repository { get; set; }

    /// <summary>Raw host string from the git remote URL (e.g. "github.com", "mycompany.ghe.com", "dev.azure.com").</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("repositoryHost")]
    public string? RepositoryHost { get; set; }
}

/// <summary>Optional session limits.</summary>
/// <remarks>Nested data type for <c>SessionLimitsConfig</c>.</remarks>
public sealed partial class SessionLimitsConfig
{
    /// <summary>Maximum AI Credits allowed across the session's current accounting window.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("maxAiCredits")]
    public double? MaxAiCredits { get; set; }
}

/// <summary>Repository context for the handed-off session.</summary>
/// <remarks>Nested data type for <c>HandoffRepository</c>.</remarks>
public sealed partial class HandoffRepository
{
    /// <summary>Git branch name, if applicable.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("branch")]
    public string? Branch { get; set; }

    /// <summary>Repository name.</summary>
    [JsonPropertyName("name")]
    public required string Name { get; set; }

    /// <summary>Repository owner (user or organization).</summary>
    [JsonPropertyName("owner")]
    public required string Owner { get; set; }
}

/// <summary>Request count and cost metrics.</summary>
/// <remarks>Nested data type for <c>ShutdownModelMetricRequests</c>.</remarks>
public sealed partial class ShutdownModelMetricRequests
{
    /// <summary>Cumulative cost multiplier for requests to this model.</summary>
    [Experimental(Diagnostics.Experimental)]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("cost")]
    public double? Cost { get; set; }

    /// <summary>Total number of API requests made to this model.</summary>
    [Experimental(Diagnostics.Experimental)]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("count")]
    public long? Count { get; set; }
}

/// <summary>A token-type entry in a shutdown model metric, storing the accumulated token count.</summary>
/// <remarks>Nested data type for <c>ShutdownModelMetricTokenDetail</c>.</remarks>
public sealed partial class ShutdownModelMetricTokenDetail
{
    /// <summary>Accumulated token count for this token type.</summary>
    [JsonPropertyName("tokenCount")]
    public required long TokenCount { get; set; }
}

/// <summary>Token usage breakdown.</summary>
/// <remarks>Nested data type for <c>ShutdownModelMetricUsage</c>.</remarks>
public sealed partial class ShutdownModelMetricUsage
{
    /// <summary>Total tokens read from prompt cache across all requests.</summary>
    [JsonPropertyName("cacheReadTokens")]
    public required long CacheReadTokens { get; set; }

    /// <summary>Total tokens written to prompt cache across all requests.</summary>
    [JsonPropertyName("cacheWriteTokens")]
    public required long CacheWriteTokens { get; set; }

    /// <summary>Total input tokens consumed across all requests to this model.</summary>
    [JsonPropertyName("inputTokens")]
    public required long InputTokens { get; set; }

    /// <summary>Total output tokens produced across all requests to this model.</summary>
    [JsonPropertyName("outputTokens")]
    public required long OutputTokens { get; set; }

    /// <summary>Total reasoning tokens produced across all requests to this model.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("reasoningTokens")]
    public long? ReasoningTokens { get; set; }
}

/// <summary>Per-model shutdown metrics with request counts, token usage, nano-AI units, and token details.</summary>
/// <remarks>Nested data type for <c>ShutdownModelMetric</c>.</remarks>
public sealed partial class ShutdownModelMetric
{
    /// <summary>Request count and cost metrics.</summary>
    [JsonPropertyName("requests")]
    public required ShutdownModelMetricRequests Requests { get; set; }

    /// <summary>Token count details per type.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("tokenDetails")]
    public IDictionary<string, ShutdownModelMetricTokenDetail>? TokenDetails { get; set; }

    /// <summary>Accumulated nano-AI units cost for this model.</summary>
    [Experimental(Diagnostics.Experimental)]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("totalNanoAiu")]
    public double? TotalNanoAiu { get; set; }

    /// <summary>Token usage breakdown.</summary>
    [JsonPropertyName("usage")]
    public required ShutdownModelMetricUsage Usage { get; set; }
}

/// <summary>Usage attributed to one agent instance at session shutdown.</summary>
/// <remarks>Nested data type for <c>ShutdownAgentMetric</c>.</remarks>
public sealed partial class ShutdownAgentMetric
{
    /// <summary>Human-readable label for this subagent invocation, copied from the originating `subagent.started` event. For task-tool subagents this is the invocation's task description rather than the agent's configured display name, so group by `agentName` for stable per-agent labels.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("agentDisplayName")]
    public string? AgentDisplayName { get; set; }

    /// <summary>Configured agent name, when this is a subagent.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("agentName")]
    public string? AgentName { get; set; }

    /// <summary>Per-model usage for this agent, keyed by model identifier.</summary>
    [JsonPropertyName("modelMetrics")]
    public required IDictionary<string, ShutdownModelMetric> ModelMetrics { get; set; }

    /// <summary>Time spent in model API calls by this agent, in milliseconds.</summary>
    [JsonConverter(typeof(MillisecondsTimeSpanConverter))]
    [JsonPropertyName("totalApiDurationMs")]
    public required TimeSpan TotalApiDuration { get; set; }

    /// <summary>Accumulated nano-AI units cost for this agent.</summary>
    [JsonPropertyName("totalNanoAiu")]
    public required double TotalNanoAiu { get; set; }
}

/// <summary>Aggregate code change metrics for the session.</summary>
/// <remarks>Nested data type for <c>ShutdownCodeChanges</c>.</remarks>
public sealed partial class ShutdownCodeChanges
{
    /// <summary>List of file paths that were modified during the session.</summary>
    [JsonPropertyName("filesModified")]
    public required string[] FilesModified { get; set; }

    /// <summary>Total number of lines added during the session.</summary>
    [JsonPropertyName("linesAdded")]
    public required long LinesAdded { get; set; }

    /// <summary>Total number of lines removed during the session.</summary>
    [JsonPropertyName("linesRemoved")]
    public required long LinesRemoved { get; set; }
}

/// <summary>A session-wide shutdown token-type entry storing the accumulated token count.</summary>
/// <remarks>Nested data type for <c>ShutdownTokenDetail</c>.</remarks>
public sealed partial class ShutdownTokenDetail
{
    /// <summary>Accumulated token count for this token type.</summary>
    [JsonPropertyName("tokenCount")]
    public required long TokenCount { get; set; }
}

/// <summary>Internal prompt-cache expiration state for one model.</summary>
/// <remarks>Nested data type for <c>UsageCheckpointModelCacheState</c>.</remarks>
internal sealed partial class UsageCheckpointModelCacheState
{
    /// <summary>Latest known prompt-cache expiration.</summary>
    [JsonPropertyName("cacheExpiresAt")]
    public required DateTimeOffset CacheExpiresAt { get; set; }

    /// <summary>Retained cache lifetime in seconds, used to refresh expiration after a cache read.</summary>
    [JsonInclude]
    [JsonPropertyName("cacheTtlSeconds")]
    internal required long CacheTtlSeconds { get; set; }

    /// <summary>Model identifier associated with this cache state.</summary>
    [JsonPropertyName("modelId")]
    public required string ModelId { get; set; }
}

/// <summary>Token usage detail for a single billing category.</summary>
/// <remarks>Nested data type for <c>CompactionCompleteCompactionTokensUsedCopilotUsageTokenDetail</c>.</remarks>
public sealed partial class CompactionCompleteCompactionTokensUsedCopilotUsageTokenDetail
{
    /// <summary>Number of tokens in this billing batch.</summary>
    [JsonPropertyName("batchSize")]
    public required long BatchSize { get; set; }

    /// <summary>Cost per batch of tokens.</summary>
    [JsonPropertyName("costPerBatch")]
    public required long CostPerBatch { get; set; }

    /// <summary>Total token count for this entry.</summary>
    [JsonPropertyName("tokenCount")]
    public required long TokenCount { get; set; }

    /// <summary>Token category (e.g., "input", "output").</summary>
    [JsonPropertyName("tokenType")]
    public required string TokenType { get; set; }
}

/// <summary>Per-request cost and usage data from the CAPI copilot_usage response field.</summary>
/// <remarks>Nested data type for <c>CompactionCompleteCompactionTokensUsedCopilotUsage</c>.</remarks>
internal sealed partial class CompactionCompleteCompactionTokensUsedCopilotUsage
{
    /// <summary>Itemized token usage breakdown.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonInclude]
    [JsonPropertyName("tokenDetails")]
    internal CompactionCompleteCompactionTokensUsedCopilotUsageTokenDetail[]? TokenDetails { get; set; }

    /// <summary>Total cost in nano-AI units for this request.</summary>
    [JsonPropertyName("totalNanoAiu")]
    public required double TotalNanoAiu { get; set; }
}

/// <summary>Token usage breakdown for the compaction LLM call (aligned with assistant.usage format).</summary>
/// <remarks>Nested data type for <c>CompactionCompleteCompactionTokensUsed</c>.</remarks>
public sealed partial class CompactionCompleteCompactionTokensUsed
{
    /// <summary>Cached input tokens reused in the compaction LLM call.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("cacheReadTokens")]
    public long? CacheReadTokens { get; set; }

    /// <summary>Tokens written to prompt cache in the compaction LLM call.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("cacheWriteTokens")]
    public long? CacheWriteTokens { get; set; }

    /// <summary>Per-request cost and usage data from the CAPI copilot_usage response field.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonInclude]
    [JsonPropertyName("copilotUsage")]
    internal CompactionCompleteCompactionTokensUsedCopilotUsage? CopilotUsage { get; set; }

    /// <summary>Duration of the compaction LLM call in milliseconds.</summary>
    [JsonConverter(typeof(MillisecondsTimeSpanConverter))]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("duration")]
    public TimeSpan? Duration { get; set; }

    /// <summary>Input tokens consumed by the compaction LLM call.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("inputTokens")]
    public long? InputTokens { get; set; }

    /// <summary>Model identifier used for the compaction LLM call.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("model")]
    public string? Model { get; set; }

    /// <summary>Output tokens produced by the compaction LLM call.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("outputTokens")]
    public long? OutputTokens { get; set; }
}

/// <summary>Inclusive durable event range summarized by a completion receipt.</summary>
/// <remarks>Nested data type for <c>CompletionReceiptEventRange</c>.</remarks>
public sealed partial class CompletionReceiptEventRange
{
    /// <summary>Identifier of the assistant turn-end event that ends the covered exchange. Always equals the receipt's sourceEventId, so either field is a valid join key.</summary>
    [JsonPropertyName("endEventId")]
    public required string EndEventId { get; set; }

    /// <summary>Identifier of the user message that starts the covered exchange.</summary>
    [JsonPropertyName("startEventId")]
    public required string StartEventId { get; set; }
}

/// <summary>Final structured tool completion in the covered event range.</summary>
/// <remarks>Nested data type for <c>CompletionReceiptFinalTool</c>.</remarks>
public sealed partial class CompletionReceiptFinalTool
{
    /// <summary>Process exit code from a structured shell result, when available.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("exitCode")]
    public long? ExitCode { get; set; }

    /// <summary>Structured success or failure status from the tool completion event.</summary>
    [JsonPropertyName("status")]
    public required CompletionReceiptToolStatus Status { get; set; }

    /// <summary>Unique identifier of the completed tool call.</summary>
    [JsonPropertyName("toolCallId")]
    public required string ToolCallId { get; set; }

    /// <summary>Tool name from the matching tool execution start event, when available.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("toolName")]
    public string? ToolName { get; set; }
}

/// <summary>Durable server recommendation for subsequent HydraFusion turns.</summary>
/// <remarks>Nested data type for <c>FusionFollowUpRecommendation</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
public sealed partial class FusionFollowUpRecommendation
{
    /// <summary>Recommended routing action for the next compaction turn.</summary>
    [JsonPropertyName("compactionTurn")]
    public required FusionFollowUpAction CompactionTurn { get; set; }

    /// <summary>Recommended routing action for the next user-message turn.</summary>
    [JsonPropertyName("userTurn")]
    public required FusionFollowUpAction UserTurn { get; set; }
}

/// <summary>Presentation-neutral phase planned for a HydraFusion turn.</summary>
/// <remarks>Nested data type for <c>FusionPhasePlanStep</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
public sealed partial class FusionPhasePlanStep
{
    /// <summary>Whether the phase executes only when an earlier phase requests it.</summary>
    [JsonPropertyName("conditional")]
    public required bool Conditional { get; set; }

    /// <summary>Kind of phase that may execute.</summary>
    [JsonPropertyName("kind")]
    public required FusionPhaseKind Kind { get; set; }

    /// <summary>Semantic role assigned to the phase.</summary>
    [JsonPropertyName("role")]
    public required string Role { get; set; }

    /// <summary>Conversation scope in which the phase executes.</summary>
    [JsonPropertyName("scope")]
    public required FusionConversationScope Scope { get; set; }
}

/// <summary>Validated HydraFusion routing capability scores.</summary>
/// <remarks>Nested data type for <c>FusionScores</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
public sealed partial class FusionScores
{
    /// <summary>Code-generation capability score returned by the authenticated router.</summary>
    [JsonPropertyName("codeGen")]
    public required double CodeGen { get; set; }

    /// <summary>Debugging capability score returned by the authenticated router.</summary>
    [JsonPropertyName("debugging")]
    public required double Debugging { get; set; }

    /// <summary>Reasoning capability score returned by the authenticated router.</summary>
    [JsonPropertyName("reasoning")]
    public required double Reasoning { get; set; }

    /// <summary>Tool-use capability score returned by the authenticated router.</summary>
    [JsonPropertyName("toolUse")]
    public required double ToolUse { get; set; }
}

/// <summary>Optional line range to scope the attachment to a specific section of the file.</summary>
/// <remarks>Nested data type for <c>AttachmentFileLineRange</c>.</remarks>
public sealed partial class AttachmentFileLineRange
{
    /// <summary>End line number (1-based, inclusive).</summary>
    [JsonPropertyName("end")]
    public required long End { get; set; }

    /// <summary>Start line number (1-based).</summary>
    [JsonPropertyName("start")]
    public required long Start { get; set; }
}

/// <summary>File attachment.</summary>
/// <remarks>The <c>file</c> variant of <see cref="Attachment"/>.</remarks>
public sealed partial class AttachmentFile : Attachment
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "file";

    /// <summary>Internal: content-addressed id of the session.binary_asset event holding this attachment's model-facing bytes (e.g. "sha256:..."). Absent externally.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("assetId")]
    public string? AssetId { get; set; }

    /// <summary>Internal: decoded byte length of the attachment's model-facing bytes. Absent externally.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("byteLength")]
    public long? ByteLength { get; set; }

    /// <summary>User-facing display name for the attachment.</summary>
    [JsonPropertyName("displayName")]
    public required string DisplayName { get; set; }

    /// <summary>Optional line range to scope the attachment to a specific section of the file.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("lineRange")]
    public AttachmentFileLineRange? LineRange { get; set; }

    /// <summary>Internal: MIME type of the file's model-facing bytes (post-resize for images). Set when the file's bytes are interned to an asset. Absent externally.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("mimeType")]
    public string? MimeType { get; set; }

    /// <summary>Internal: why model-facing bytes are absent from persistence. Absent externally.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("omittedReason")]
    public OmittedBinaryOmittedReason? OmittedReason { get; set; }

    /// <summary>Absolute file path.</summary>
    [JsonPropertyName("path")]
    public required string Path { get; set; }

    /// <summary>Frozen rendered line this attachment contributed to the &lt;tagged_files&gt; prompt block (e.g. "* /path (123 lines)"). Captured at send time so resumed history reproduces the exact text the model saw, independent of later filesystem changes. Present only for attachments routed to &lt;tagged_files&gt; (mutually exclusive with assetId, which marks bytes sent natively).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("taggedFilesEntry")]
    public string? TaggedFilesEntry { get; set; }
}

/// <summary>Directory attachment.</summary>
/// <remarks>The <c>directory</c> variant of <see cref="Attachment"/>.</remarks>
public sealed partial class AttachmentDirectory : Attachment
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "directory";

    /// <summary>User-facing display name for the attachment.</summary>
    [JsonPropertyName("displayName")]
    public required string DisplayName { get; set; }

    /// <summary>Absolute directory path.</summary>
    [JsonPropertyName("path")]
    public required string Path { get; set; }

    /// <summary>Frozen rendered line this attachment contributed to the &lt;tagged_files&gt; prompt block (e.g. "* /path (12 items)"). Captured at send time so resumed history reproduces the exact text the model saw, independent of later filesystem changes.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("taggedFilesEntry")]
    public string? TaggedFilesEntry { get; set; }
}

/// <summary>End position of the selection.</summary>
/// <remarks>Nested data type for <c>AttachmentSelectionDetailsEnd</c>.</remarks>
public sealed partial class AttachmentSelectionDetailsEnd
{
    /// <summary>End character offset within the line (0-based).</summary>
    [JsonPropertyName("character")]
    public required long Character { get; set; }

    /// <summary>End line number (0-based).</summary>
    [JsonPropertyName("line")]
    public required long Line { get; set; }
}

/// <summary>Start position of the selection.</summary>
/// <remarks>Nested data type for <c>AttachmentSelectionDetailsStart</c>.</remarks>
public sealed partial class AttachmentSelectionDetailsStart
{
    /// <summary>Start character offset within the line (0-based).</summary>
    [JsonPropertyName("character")]
    public required long Character { get; set; }

    /// <summary>Start line number (0-based).</summary>
    [JsonPropertyName("line")]
    public required long Line { get; set; }
}

/// <summary>Position range of the selection within the file.</summary>
/// <remarks>Nested data type for <c>AttachmentSelectionDetails</c>.</remarks>
public sealed partial class AttachmentSelectionDetails
{
    /// <summary>End position of the selection.</summary>
    [JsonPropertyName("end")]
    public required AttachmentSelectionDetailsEnd End { get; set; }

    /// <summary>Start position of the selection.</summary>
    [JsonPropertyName("start")]
    public required AttachmentSelectionDetailsStart Start { get; set; }
}

/// <summary>Code selection attachment from an editor.</summary>
/// <remarks>The <c>selection</c> variant of <see cref="Attachment"/>.</remarks>
public sealed partial class AttachmentSelection : Attachment
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "selection";

    /// <summary>User-facing display name for the selection.</summary>
    [JsonPropertyName("displayName")]
    public required string DisplayName { get; set; }

    /// <summary>Absolute path to the file containing the selection.</summary>
    [JsonPropertyName("filePath")]
    public required string FilePath { get; set; }

    /// <summary>Position range of the selection within the file.</summary>
    [JsonPropertyName("selection")]
    public required AttachmentSelectionDetails Selection { get; set; }

    /// <summary>The selected text content.</summary>
    [JsonPropertyName("text")]
    public required string Text { get; set; }
}

/// <summary>GitHub issue, pull request, or discussion reference.</summary>
/// <remarks>The <c>github_reference</c> variant of <see cref="Attachment"/>.</remarks>
public sealed partial class AttachmentGitHubReference : Attachment
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "github_reference";

    /// <summary>Issue, pull request, or discussion number.</summary>
    [JsonPropertyName("number")]
    public required long Number { get; set; }

    /// <summary>Type of GitHub reference.</summary>
    [JsonPropertyName("referenceType")]
    public required AttachmentGitHubReferenceType ReferenceType { get; set; }

    /// <summary>Current state of the referenced item (e.g., open, closed, merged).</summary>
    [JsonPropertyName("state")]
    public required string State { get; set; }

    /// <summary>Title of the referenced item.</summary>
    [JsonPropertyName("title")]
    public required string Title { get; set; }

    /// <summary>URL to the referenced item on GitHub.</summary>
    [JsonPropertyName("url")]
    public required string Url { get; set; }
}

/// <summary>Pointer to a GitHub repository.</summary>
/// <remarks>Nested data type for <c>GitHubRepoRef</c>.</remarks>
public sealed partial class GitHubRepoRef
{
    /// <summary>Numeric GitHub repository id.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("id")]
    public long? Id { get; set; }

    /// <summary>Repository name (without owner).</summary>
    [JsonPropertyName("name")]
    public required string Name { get; set; }

    /// <summary>Repository owner login (user or organization).</summary>
    [JsonPropertyName("owner")]
    public required string Owner { get; set; }
}

/// <summary>Pointer to a GitHub commit.</summary>
/// <remarks>The <c>github_commit</c> variant of <see cref="Attachment"/>.</remarks>
public sealed partial class AttachmentGitHubCommit : Attachment
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "github_commit";

    /// <summary>First line of the commit message.</summary>
    [JsonPropertyName("message")]
    public required string Message { get; set; }

    /// <summary>Full commit SHA.</summary>
    [JsonPropertyName("oid")]
    public required string Oid { get; set; }

    /// <summary>Repository the commit belongs to.</summary>
    [JsonPropertyName("repo")]
    public required GitHubRepoRef Repo { get; set; }

    /// <summary>URL to the commit on GitHub.</summary>
    [JsonPropertyName("url")]
    public required string Url { get; set; }
}

/// <summary>Pointer to a GitHub release.</summary>
/// <remarks>The <c>github_release</c> variant of <see cref="Attachment"/>.</remarks>
public sealed partial class AttachmentGitHubRelease : Attachment
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "github_release";

    /// <summary>Human-readable release name.</summary>
    [JsonPropertyName("name")]
    public required string Name { get; set; }

    /// <summary>Repository the release belongs to.</summary>
    [JsonPropertyName("repo")]
    public required GitHubRepoRef Repo { get; set; }

    /// <summary>Git tag the release is anchored to.</summary>
    [JsonPropertyName("tagName")]
    public required string TagName { get; set; }

    /// <summary>URL to the release on GitHub.</summary>
    [JsonPropertyName("url")]
    public required string Url { get; set; }
}

/// <summary>Pointer to a GitHub Actions job.</summary>
/// <remarks>The <c>github_actions_job</c> variant of <see cref="Attachment"/>.</remarks>
public sealed partial class AttachmentGitHubActionsJob : Attachment
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "github_actions_job";

    /// <summary>Terminal conclusion of the job when finished (e.g., success, failure, cancelled). Absent for in-progress jobs.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("conclusion")]
    public string? Conclusion { get; set; }

    /// <summary>Job id within the workflow run.</summary>
    [JsonPropertyName("jobId")]
    public required long JobId { get; set; }

    /// <summary>Display name of the job.</summary>
    [JsonPropertyName("jobName")]
    public required string JobName { get; set; }

    /// <summary>Repository the workflow run belongs to.</summary>
    [JsonPropertyName("repo")]
    public required GitHubRepoRef Repo { get; set; }

    /// <summary>URL to the job on GitHub.</summary>
    [JsonPropertyName("url")]
    public required string Url { get; set; }

    /// <summary>Display name of the workflow the job ran in.</summary>
    [JsonPropertyName("workflowName")]
    public required string WorkflowName { get; set; }
}

/// <summary>Pointer to a GitHub repository.</summary>
/// <remarks>The <c>github_repository</c> variant of <see cref="Attachment"/>.</remarks>
public sealed partial class AttachmentGitHubRepository : Attachment
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "github_repository";

    /// <summary>Short description of the repository.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("description")]
    public string? Description { get; set; }

    /// <summary>Git ref this attachment is anchored at (branch, tag, or commit). When absent the default branch is implied.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("ref")]
    public string? Ref { get; set; }

    /// <summary>Repository pointer.</summary>
    [JsonPropertyName("repo")]
    public required GitHubRepoRef Repo { get; set; }

    /// <summary>URL to the repository on GitHub.</summary>
    [JsonPropertyName("url")]
    public required string Url { get; set; }
}

/// <summary>One side of a file diff (head or base).</summary>
/// <remarks>Nested data type for <c>AttachmentGitHubFileDiffSide</c>.</remarks>
public sealed partial class AttachmentGitHubFileDiffSide
{
    /// <summary>Repository-relative path to the file.</summary>
    [JsonPropertyName("path")]
    public required string Path { get; set; }

    /// <summary>Git ref (branch, tag, or commit SHA) the file is read at.</summary>
    [JsonPropertyName("ref")]
    public required string Ref { get; set; }

    /// <summary>Repository the file lives in.</summary>
    [JsonPropertyName("repo")]
    public required GitHubRepoRef Repo { get; set; }
}

/// <summary>Pointer to a single-file diff. At least one of `head` and `base` must be present.</summary>
/// <remarks>The <c>github_file_diff</c> variant of <see cref="Attachment"/>.</remarks>
public sealed partial class AttachmentGitHubFileDiff : Attachment
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "github_file_diff";

    /// <summary>File location on the base side of the diff. Absent for additions.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("base")]
    public AttachmentGitHubFileDiffSide? Base { get; set; }

    /// <summary>File location on the head side of the diff. Absent for deletions.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("head")]
    public AttachmentGitHubFileDiffSide? Head { get; set; }

    /// <summary>URL to the diff on GitHub (e.g., a commit, compare, or PR-file URL).</summary>
    [JsonPropertyName("url")]
    public required string Url { get; set; }
}

/// <summary>One side of a tree comparison (head or base).</summary>
/// <remarks>Nested data type for <c>AttachmentGitHubTreeComparisonSide</c>.</remarks>
public sealed partial class AttachmentGitHubTreeComparisonSide
{
    /// <summary>Repository the revision belongs to.</summary>
    [JsonPropertyName("repo")]
    public required GitHubRepoRef Repo { get; set; }

    /// <summary>Git revision (branch, tag, or commit SHA).</summary>
    [JsonPropertyName("revision")]
    public required string Revision { get; set; }
}

/// <summary>Pointer to a comparison between two git revisions.</summary>
/// <remarks>The <c>github_tree_comparison</c> variant of <see cref="Attachment"/>.</remarks>
public sealed partial class AttachmentGitHubTreeComparison : Attachment
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "github_tree_comparison";

    /// <summary>Base side of the comparison.</summary>
    [JsonPropertyName("base")]
    public required AttachmentGitHubTreeComparisonSide Base { get; set; }

    /// <summary>Head side of the comparison.</summary>
    [JsonPropertyName("head")]
    public required AttachmentGitHubTreeComparisonSide Head { get; set; }

    /// <summary>URL to the comparison on GitHub.</summary>
    [JsonPropertyName("url")]
    public required string Url { get; set; }
}

/// <summary>Generic GitHub URL reference.</summary>
/// <remarks>The <c>github_url</c> variant of <see cref="Attachment"/>.</remarks>
public sealed partial class AttachmentGitHubUrl : Attachment
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "github_url";

    /// <summary>URL to the GitHub resource.</summary>
    [JsonPropertyName("url")]
    public required string Url { get; set; }
}

/// <summary>Pointer to a file in a GitHub repository at a specific ref.</summary>
/// <remarks>The <c>github_file</c> variant of <see cref="Attachment"/>.</remarks>
public sealed partial class AttachmentGitHubFile : Attachment
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "github_file";

    /// <summary>Repository-relative path to the file.</summary>
    [JsonPropertyName("path")]
    public required string Path { get; set; }

    /// <summary>Git ref the file is read at (branch, tag, or commit SHA).</summary>
    [JsonPropertyName("ref")]
    public required string Ref { get; set; }

    /// <summary>Repository the file lives in.</summary>
    [JsonPropertyName("repo")]
    public required GitHubRepoRef Repo { get; set; }

    /// <summary>URL to the file on GitHub.</summary>
    [JsonPropertyName("url")]
    public required string Url { get; set; }
}

/// <summary>Pointer to a line range inside a file in a GitHub repository.</summary>
/// <remarks>The <c>github_snippet</c> variant of <see cref="Attachment"/>.</remarks>
public sealed partial class AttachmentGitHubSnippet : Attachment
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "github_snippet";

    /// <summary>Line range the snippet covers.</summary>
    [JsonPropertyName("lineRange")]
    public required AttachmentFileLineRange LineRange { get; set; }

    /// <summary>Repository-relative path to the file.</summary>
    [JsonPropertyName("path")]
    public required string Path { get; set; }

    /// <summary>Git ref the file is read at (branch, tag, or commit SHA).</summary>
    [JsonPropertyName("ref")]
    public required string Ref { get; set; }

    /// <summary>Repository the file lives in.</summary>
    [JsonPropertyName("repo")]
    public required GitHubRepoRef Repo { get; set; }

    /// <summary>URL to the snippet on GitHub (with line anchor).</summary>
    [JsonPropertyName("url")]
    public required string Url { get; set; }
}

/// <summary>Blob attachment with inline base64-encoded data.</summary>
/// <remarks>The <c>blob</c> variant of <see cref="Attachment"/>.</remarks>
public sealed partial class AttachmentBlob : Attachment
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "blob";

    /// <summary>Internal: content-addressed id of the session.binary_asset event holding this attachment's model-facing bytes (e.g. "sha256:..."). Absent externally.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("assetId")]
    public string? AssetId { get; set; }

    /// <summary>Internal: decoded byte length of the attachment's model-facing bytes. Absent externally.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("byteLength")]
    public long? ByteLength { get; set; }

    /// <summary>Base64-encoded content. Present on input and for external consumers; replaced by an internal `assetId` reference in persisted events when interned to a content-addressed asset.</summary>
    [Base64String]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("data")]
    public string? Data { get; set; }

    /// <summary>User-facing display name for the attachment.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("displayName")]
    public string? DisplayName { get; set; }

    /// <summary>MIME type of the inline data.</summary>
    [JsonPropertyName("mimeType")]
    public required string MimeType { get; set; }

    /// <summary>Internal: why model-facing bytes are absent from persistence. Absent externally.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("omittedReason")]
    public OmittedBinaryOmittedReason? OmittedReason { get; set; }
}

/// <summary>Structured context contributed by an extension. Composer pills displayed in the host are forwarded back through session.send.attachments, then rendered into the model prompt as an &lt;extension_context&gt; XML block.</summary>
/// <remarks>The <c>extension_context</c> variant of <see cref="Attachment"/>.</remarks>
public sealed partial class AttachmentExtensionContext : Attachment
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "extension_context";

    /// <summary>Provider-local canvas identifier when the push was bound to a canvas instance.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("canvasId")]
    public string? CanvasId { get; set; }

    /// <summary>ISO 8601 timestamp captured by the runtime when the push was accepted.</summary>
    [JsonPropertyName("capturedAt")]
    public required DateTimeOffset CapturedAt { get; set; }

    /// <summary>Owning extension identifier. Runtime-derived from the caller's connection when produced via session.extensions.sendAttachmentsToMessage; preserved verbatim on subsequent transports.</summary>
    [JsonPropertyName("extensionId")]
    public required string ExtensionId { get; set; }

    /// <summary>Open canvas instance identifier when the push was bound to a canvas instance.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("instanceId")]
    public string? InstanceId { get; set; }

    /// <summary>Caller-supplied JSON payload.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("payload")]
    public JsonElement? Payload { get; set; }

    /// <summary>Human-readable composer pill label.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("title")]
    public required string Title { get; set; }
}

/// <summary>A user message attachment — a file, directory, code selection, blob, GitHub reference, GitHub-anchored pointer, or extension-supplied context payload.</summary>
/// <remarks>Polymorphic base type discriminated by <c>type</c>.</remarks>
[JsonPolymorphic(
    TypeDiscriminatorPropertyName = "type",
    UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FallBackToBaseType)]
[JsonDerivedType(typeof(AttachmentFile), "file")]
[JsonDerivedType(typeof(AttachmentDirectory), "directory")]
[JsonDerivedType(typeof(AttachmentSelection), "selection")]
[JsonDerivedType(typeof(AttachmentGitHubReference), "github_reference")]
[JsonDerivedType(typeof(AttachmentGitHubCommit), "github_commit")]
[JsonDerivedType(typeof(AttachmentGitHubRelease), "github_release")]
[JsonDerivedType(typeof(AttachmentGitHubActionsJob), "github_actions_job")]
[JsonDerivedType(typeof(AttachmentGitHubRepository), "github_repository")]
[JsonDerivedType(typeof(AttachmentGitHubFileDiff), "github_file_diff")]
[JsonDerivedType(typeof(AttachmentGitHubTreeComparison), "github_tree_comparison")]
[JsonDerivedType(typeof(AttachmentGitHubUrl), "github_url")]
[JsonDerivedType(typeof(AttachmentGitHubFile), "github_file")]
[JsonDerivedType(typeof(AttachmentGitHubSnippet), "github_snippet")]
[JsonDerivedType(typeof(AttachmentBlob), "blob")]
[JsonDerivedType(typeof(AttachmentExtensionContext), "extension_context")]
public partial class Attachment
{
    /// <summary>The type discriminator.</summary>
    [JsonPropertyName("type")]
    public virtual string Type { get; set; } = string.Empty;
}


/// <summary>Internal durable terminal request staged by a HydraFusion phase until an idempotent final commit selects it.</summary>
/// <remarks>Nested data type for <c>FusionStagedTerminal</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
internal sealed partial class FusionStagedTerminal
{
    /// <summary>Gets or sets the <c>arguments</c> value.</summary>
    [JsonPropertyName("arguments")]
    public required string Arguments { get; set; }

    /// <summary>Gets or sets the <c>assistantMessage</c> value.</summary>
    [JsonPropertyName("assistantMessage")]
    public required JsonElement AssistantMessage { get; set; }

    /// <summary>Gets or sets the <c>phaseId</c> value.</summary>
    [JsonPropertyName("phaseId")]
    public required string PhaseId { get; set; }

    /// <summary>Gets or sets the <c>toolCallId</c> value.</summary>
    [JsonPropertyName("toolCallId")]
    public required string ToolCallId { get; set; }

    /// <summary>Gets or sets the <c>toolName</c> value.</summary>
    [JsonPropertyName("toolName")]
    public required string ToolName { get; set; }
}

/// <summary>Aggregate concrete-model usage for one HydraFusion phase.</summary>
/// <remarks>Nested data type for <c>FusionPhaseUsage</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
public sealed partial class FusionPhaseUsage
{
    /// <summary>Total cached input tokens reported for the phase.</summary>
    [JsonPropertyName("cachedTokens")]
    public required long CachedTokens { get; set; }

    /// <summary>Total tokens written to prompt cache during the phase.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("cacheWriteTokens")]
    public long? CacheWriteTokens { get; set; }

    /// <summary>Total input tokens consumed by the phase.</summary>
    [JsonPropertyName("inputTokens")]
    public required long InputTokens { get; set; }

    /// <summary>Total output tokens produced by the phase.</summary>
    [JsonPropertyName("outputTokens")]
    public required long OutputTokens { get; set; }

    /// <summary>Number of concrete model requests made by the phase.</summary>
    [JsonPropertyName("requestCount")]
    public required long RequestCount { get; set; }

    /// <summary>Total normalized AI-unit cost reported for the phase, in nano-AIU.</summary>
    [JsonPropertyName("totalNanoAiu")]
    public required double TotalNanoAiu { get; set; }
}

/// <summary>A source that backs one or more cited spans in the assistant's response.</summary>
/// <remarks>Nested data type for <c>CitationSource</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
public sealed partial class CitationSource
{
    /// <summary>Stable, turn-scoped identifier for this source, referenced by CitationReference.sourceId.</summary>
    [JsonPropertyName("id")]
    public required string Id { get; set; }

    /// <summary>File path relative to the agent's workspace root, when the source is a file.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("path")]
    public string? Path { get; set; }

    /// <summary>The system that produced this citation.</summary>
    [JsonPropertyName("provider")]
    public required CitationProvider Provider { get; set; }

    /// <summary>Human-readable title of the source.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("title")]
    public string? Title { get; set; }

    /// <summary>URL of the source, when it is a web resource.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("url")]
    public string? Url { get; set; }
}

/// <summary>A character range within the source's text content.</summary>
/// <remarks>The <c>char</c> variant of <see cref="CitationLocation"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public sealed partial class CitationLocationChar : CitationLocation
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "char";

    /// <summary>End character offset within the source text (zero-based, exclusive).</summary>
    [JsonPropertyName("endIndex")]
    public required long EndIndex { get; set; }

    /// <summary>Start character offset within the source text (zero-based, inclusive).</summary>
    [JsonPropertyName("startIndex")]
    public required long StartIndex { get; set; }
}

/// <summary>A page range within a paginated source document.</summary>
/// <remarks>The <c>page</c> variant of <see cref="CitationLocation"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public sealed partial class CitationLocationPage : CitationLocation
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "page";

    /// <summary>Last page number of the cited range (inclusive).</summary>
    [JsonPropertyName("endPage")]
    public required long EndPage { get; set; }

    /// <summary>First page number of the cited range.</summary>
    [JsonPropertyName("startPage")]
    public required long StartPage { get; set; }
}

/// <summary>A content-block range within a structured source document.</summary>
/// <remarks>The <c>block</c> variant of <see cref="CitationLocation"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public sealed partial class CitationLocationBlock : CitationLocation
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "block";

    /// <summary>Index of the last content block of the cited range (zero-based, exclusive).</summary>
    [JsonPropertyName("endBlock")]
    public required long EndBlock { get; set; }

    /// <summary>Index of the first content block of the cited range (zero-based, inclusive).</summary>
    [JsonPropertyName("startBlock")]
    public required long StartBlock { get; set; }
}

/// <summary>Location within a cited source (character, page, or content-block range) that supports a span.</summary>
/// <remarks>Polymorphic base type discriminated by <c>type</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
[JsonPolymorphic(
    TypeDiscriminatorPropertyName = "type",
    UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FallBackToBaseType)]
[JsonDerivedType(typeof(CitationLocationChar), "char")]
[JsonDerivedType(typeof(CitationLocationPage), "page")]
[JsonDerivedType(typeof(CitationLocationBlock), "block")]
public partial class CitationLocation
{
    /// <summary>The type discriminator.</summary>
    [JsonPropertyName("type")]
    public virtual string Type { get; set; } = string.Empty;
}


/// <summary>A single citation occurrence linking a span of generated text to a supporting source.</summary>
/// <remarks>Nested data type for <c>CitationReference</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
public sealed partial class CitationReference
{
    /// <summary>The exact text from the source that supports the cited span, when provided by the model.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("citedText")]
    public string? CitedText { get; set; }

    /// <summary>Location within the source that supports the cited span, when the provider reports one.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("location")]
    public CitationLocation? Location { get; set; }

    /// <summary>Provider-native citation correlation data (e.g. Anthropic search_result_index / document_index), passed through opaquely for debugging and forward compatibility.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("providerMetadata")]
    public JsonElement? ProviderMetadata { get; set; }

    /// <summary>Identifier of the CitationSource this reference points to (CitationSource.id).</summary>
    [JsonPropertyName("sourceId")]
    public required string SourceId { get; set; }
}

/// <summary>A contiguous span of generated assistant text and the source references that support it.</summary>
/// <remarks>Nested data type for <c>CitationSpan</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
public sealed partial class CitationSpan
{
    /// <summary>End offset of the cited span within the final assistant message content (UTF-16 code units, zero-based, exclusive).</summary>
    [JsonPropertyName("endIndex")]
    public required long EndIndex { get; set; }

    /// <summary>The sources that support this span of generated text.</summary>
    [JsonPropertyName("references")]
    public required CitationReference[] References { get; set; }

    /// <summary>Start offset of the cited span within the final assistant message content (UTF-16 code units, zero-based, inclusive).</summary>
    [JsonPropertyName("startIndex")]
    public required long StartIndex { get; set; }
}

/// <summary>Provider-agnostic citations linking spans of the assistant's response to their supporting sources.</summary>
/// <remarks>Nested data type for <c>Citations</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
public sealed partial class Citations
{
    /// <summary>Deduplicated set of sources referenced by the citation spans.</summary>
    [JsonPropertyName("sources")]
    public required CitationSource[] Sources { get; set; }

    /// <summary>Spans of generated text annotated with the sources that support them.</summary>
    [JsonPropertyName("spans")]
    public required CitationSpan[] Spans { get; set; }
}

/// <summary>Experimental attribution linking an ordinary event to the HydraFusion turn, phase, and concrete source that produced it.</summary>
/// <remarks>Nested data type for <c>FusionAttribution</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
public sealed partial class FusionAttribution
{
    /// <summary>Idempotency identifier for the authoritative commit, when the event belongs to the selected output.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("commitId")]
    public string? CommitId { get; set; }

    /// <summary>Conversation scope in which the concrete phase executed.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("conversationScope")]
    public string? ConversationScope { get; set; }

    /// <summary>Stable identifier for the HydraFusion turn that produced the event.</summary>
    [JsonPropertyName("fusionId")]
    public required string FusionId { get; set; }

    /// <summary>HydraFusion orchestration pattern selected for the turn.</summary>
    [JsonPropertyName("pattern")]
    public required string Pattern { get; set; }

    /// <summary>Identifier of the concrete phase that produced the event.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("phaseId")]
    public string? PhaseId { get; set; }

    /// <summary>Kind of concrete phase that produced the event.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("phaseKind")]
    public string? PhaseKind { get; set; }

    /// <summary>HydraFusion routing policy used for the turn.</summary>
    [JsonPropertyName("policy")]
    public required string Policy { get; set; }

    /// <summary>Semantic role assigned to the concrete phase.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("role")]
    public string? Role { get; set; }

    /// <summary>Concrete model that produced the attributed event.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("sourceModel")]
    public string? SourceModel { get; set; }

    /// <summary>Phase whose output supplied the authoritative content, when different from the executing phase.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("sourcePhaseId")]
    public string? SourcePhaseId { get; set; }

    /// <summary>Synthetic HydraFusion model selected for the session.</summary>
    [JsonPropertyName("syntheticModel")]
    public required string SyntheticModel { get; set; }
}

/// <summary>Neutral provider-tagged reasoning content blocks preserved verbatim for round-tripping.</summary>
/// <remarks>Nested data type for <c>AssistantMessageReasoningBlocks</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
public sealed partial class AssistantMessageReasoningBlocks
{
    /// <summary>Provider-native reasoning items or content blocks preserved verbatim, in order. A single response can carry several, and provider signatures or identifiers may depend on their exact content and ordering.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("blocks")]
    public JsonElement[]? Blocks { get; set; }

    /// <summary>Model provider that produced these reasoning blocks.</summary>
    [JsonPropertyName("provider")]
    public required string Provider { get; set; }
}

/// <summary>Neutral provider-tagged server-side tool-use payload (tool search, advisor) for verbatim round-tripping.</summary>
/// <remarks>Nested data type for <c>AssistantMessageServerTools</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
public sealed partial class AssistantMessageServerTools
{
    /// <summary>Advisor model identifier associated with the server-tool payload.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("advisorModel")]
    public string? AdvisorModel { get; set; }

    /// <summary>Provider function-call namespaces keyed by function-call identifier.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("functionCallNamespaces")]
    public IDictionary<string, string>? FunctionCallNamespaces { get; set; }

    /// <summary>Provider-native server-tool call and output items preserved verbatim for replay.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("items")]
    public JsonElement[]? Items { get; set; }

    /// <summary>Model provider that produced this server-tool payload.</summary>
    [JsonPropertyName("provider")]
    public required string Provider { get; set; }

    /// <summary>Raw provider content blocks retained for verbatim round-tripping.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("rawContentBlocks")]
    public JsonElement[]? RawContentBlocks { get; set; }
}

/// <summary>Hosted program that requested this client tool call.</summary>
/// <remarks>Nested data type for <c>AssistantMessageToolRequestCaller</c>.</remarks>
public sealed partial class AssistantMessageToolRequestCaller
{
    /// <summary>Provider-assigned identifier for the hosted caller.</summary>
    [JsonPropertyName("callerId")]
    public required string CallerId { get; set; }

    /// <summary>Kind of hosted caller that requested the client tool call.</summary>
    [JsonPropertyName("type")]
    public required AssistantMessageToolRequestCallerType Type { get; set; }
}

/// <summary>A tool invocation request from the assistant.</summary>
/// <remarks>Nested data type for <c>AssistantMessageToolRequest</c>.</remarks>
public sealed partial class AssistantMessageToolRequest
{
    /// <summary>Arguments to pass to the tool, format depends on the tool.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("arguments")]
    public JsonElement? Arguments { get; set; }

    /// <summary>Hosted program that requested this client tool call.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("caller")]
    public AssistantMessageToolRequestCaller? Caller { get; set; }

    /// <summary>Resolved intention summary describing what this specific call does.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("intentionSummary")]
    public string? IntentionSummary { get; set; }

    /// <summary>Name of the MCP server hosting this tool, when the tool is an MCP tool.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("mcpServerName")]
    public string? McpServerName { get; set; }

    /// <summary>Original tool name on the MCP server, when the tool is an MCP tool.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("mcpToolName")]
    public string? McpToolName { get; set; }

    /// <summary>Name of the tool being invoked.</summary>
    [JsonPropertyName("name")]
    public required string Name { get; set; }

    /// <summary>Unique identifier for this tool call.</summary>
    [JsonPropertyName("toolCallId")]
    public required string ToolCallId { get; set; }

    /// <summary>Human-readable display title for the tool.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("toolTitle")]
    public string? ToolTitle { get; set; }

    /// <summary>Tool call type: "function" for standard tool calls, "custom" for grammar-based tool calls. Defaults to "function" when absent.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("type")]
    public AssistantMessageToolRequestType? Type { get; set; }
}

/// <summary>Token usage detail for a single billing category.</summary>
/// <remarks>Nested data type for <c>AssistantUsageCopilotUsageTokenDetail</c>.</remarks>
public sealed partial class AssistantUsageCopilotUsageTokenDetail
{
    /// <summary>Number of tokens in this billing batch.</summary>
    [JsonPropertyName("batchSize")]
    public required long BatchSize { get; set; }

    /// <summary>Cost per batch of tokens.</summary>
    [JsonPropertyName("costPerBatch")]
    public required long CostPerBatch { get; set; }

    /// <summary>Total token count for this entry.</summary>
    [JsonPropertyName("tokenCount")]
    public required long TokenCount { get; set; }

    /// <summary>Token category (e.g., "input", "output").</summary>
    [JsonPropertyName("tokenType")]
    public required string TokenType { get; set; }
}

/// <summary>Per-request cost and usage data from the CAPI copilot_usage response field.</summary>
/// <remarks>Nested data type for <c>AssistantUsageCopilotUsage</c>.</remarks>
public sealed partial class AssistantUsageCopilotUsage
{
    /// <summary>Itemized token usage breakdown.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonInclude]
    [JsonPropertyName("tokenDetails")]
    internal AssistantUsageCopilotUsageTokenDetail[]? TokenDetails { get; set; }

    /// <summary>Total cost in nano-AI units for this request.</summary>
    [JsonPropertyName("totalNanoAiu")]
    public required double TotalNanoAiu { get; set; }
}

/// <summary>Internal per-quota snapshot for assistant usage, including entitlement, consumed requests, overage, reset date, and remaining quota.</summary>
/// <remarks>Nested data type for <c>AssistantUsageQuotaSnapshot</c>.</remarks>
internal sealed partial class AssistantUsageQuotaSnapshot
{
    /// <summary>Total requests allowed by the entitlement.</summary>
    [JsonInclude]
    [JsonPropertyName("entitlementRequests")]
    internal required long EntitlementRequests { get; set; }

    /// <summary>Whether the user currently has quota available for use.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonInclude]
    [JsonPropertyName("hasQuota")]
    internal bool? HasQuota { get; set; }

    /// <summary>Whether the user has an unlimited usage entitlement.</summary>
    [JsonInclude]
    [JsonPropertyName("isUnlimitedEntitlement")]
    internal required bool IsUnlimitedEntitlement { get; set; }

    /// <summary>Number of additional usage requests made this period.</summary>
    [JsonInclude]
    [JsonPropertyName("overage")]
    internal required double Overage { get; set; }

    /// <summary>Whether additional usage is allowed when quota is exhausted.</summary>
    [JsonInclude]
    [JsonPropertyName("overageAllowedWithExhaustedQuota")]
    internal required bool OverageAllowedWithExhaustedQuota { get; set; }

    /// <summary>Pay-as-you-go additional-usage budget cap in AI credits (1 credit = $0.01); present only when CAPI emits a finite value.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonInclude]
    [JsonPropertyName("overageEntitlement")]
    internal double? OverageEntitlement { get; set; }

    /// <summary>Percentage of quota remaining (0 to 100).</summary>
    [JsonInclude]
    [JsonPropertyName("remainingPercentage")]
    internal required double RemainingPercentage { get; set; }

    /// <summary>Date when the quota resets.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonInclude]
    [JsonPropertyName("resetDate")]
    internal DateTimeOffset? ResetDate { get; set; }

    /// <summary>Whether this snapshot uses token-based billing (AI-credits allocation).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonInclude]
    [JsonPropertyName("tokenBasedBilling")]
    internal bool? TokenBasedBilling { get; set; }

    /// <summary>Whether usage is still permitted after quota exhaustion.</summary>
    [JsonInclude]
    [JsonPropertyName("usageAllowedWithExhaustedQuota")]
    internal required bool UsageAllowedWithExhaustedQuota { get; set; }

    /// <summary>Number of requests already consumed.</summary>
    [JsonInclude]
    [JsonPropertyName("usedRequests")]
    internal required long UsedRequests { get; set; }
}

/// <summary>Content-free structural summary of the failing request for diagnosing malformed 4xx calls.</summary>
/// <remarks>Nested data type for <c>ModelCallFailureRequestFingerprint</c>.</remarks>
public sealed partial class ModelCallFailureRequestFingerprint
{
    /// <summary>Total number of image content parts.</summary>
    [JsonPropertyName("imagePartCount")]
    public required long ImagePartCount { get; set; }

    /// <summary>Image parts whose media type cannot be determined (rejected by strict providers).</summary>
    [JsonPropertyName("imagePartsMissingMediaType")]
    public required long ImagePartsMissingMediaType { get; set; }

    /// <summary>Role of the final message in the request.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("lastMessageRole")]
    public string? LastMessageRole { get; set; }

    /// <summary>Total number of messages in the request.</summary>
    [JsonPropertyName("messageCount")]
    public required long MessageCount { get; set; }

    /// <summary>Tool calls whose name is missing or empty (rejected by strict providers).</summary>
    [JsonPropertyName("namelessToolCallCount")]
    public required long NamelessToolCallCount { get; set; }

    /// <summary>Total number of tool calls across assistant messages.</summary>
    [JsonPropertyName("toolCallCount")]
    public required long ToolCallCount { get; set; }

    /// <summary>Number of "tool" result messages in the request.</summary>
    [JsonPropertyName("toolResultMessageCount")]
    public required long ToolResultMessageCount { get; set; }
}

/// <summary>Shell-aware path hints for a shell tool's command, captured at start time so consumers can snapshot a file's pre-image before the tool runs.</summary>
/// <remarks>Nested data type for <c>ToolExecutionStartShellToolInfo</c>.</remarks>
public sealed partial class ToolExecutionStartShellToolInfo
{
    /// <summary>The command with a redundant leading `cd` into the working directory removed, present only when there was one to remove. Computed with the same routine the shell driver applies before spawning, so a surface that renders this shows the text that actually runs. Consumers that display it should keep the original tool arguments available on demand.</summary>
    [Experimental(Diagnostics.Experimental)]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("displayCommand")]
    public string? DisplayCommand { get; set; }

    /// <summary>Whether the command includes a file write redirection (e.g., &gt; or &gt;&gt;).</summary>
    [JsonPropertyName("hasWriteFileRedirection")]
    public required bool HasWriteFileRedirection { get; set; }

    /// <summary>File paths the command may read or write, derived from the command at start time. Produced by the same shell-aware extractor as PermissionRequestShell.possiblePaths, so it is present even when the command is auto-approved and no permission request fires.</summary>
    [JsonPropertyName("possiblePaths")]
    public required string[] PossiblePaths { get; set; }
}

/// <summary>MCP Apps tool `_meta.ui` resource URI and visibility captured on `tool.execution_start`.</summary>
/// <remarks>Nested data type for <c>ToolExecutionStartToolDescriptionMetaUI</c>.</remarks>
public sealed partial class ToolExecutionStartToolDescriptionMetaUI
{
    /// <summary>URI of the UI resource.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("resourceUri")]
    public string? ResourceUri { get; set; }

    /// <summary>Who can access this tool.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("visibility")]
    public ToolExecutionStartToolDescriptionMetaUIVisibility[]? Visibility { get; set; }
}

/// <summary>MCP Apps metadata for UI resource association.</summary>
/// <remarks>Nested data type for <c>ToolExecutionStartToolDescriptionMeta</c>.</remarks>
public sealed partial class ToolExecutionStartToolDescriptionMeta
{
    /// <summary>MCP Apps tool `_meta.ui` resource URI and visibility captured on `tool.execution_start`.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("ui")]
    public ToolExecutionStartToolDescriptionMetaUI? Ui { get; set; }
}

/// <summary>Tool definition metadata, present for MCP tools with MCP Apps support.</summary>
/// <remarks>Nested data type for <c>ToolExecutionStartToolDescription</c>.</remarks>
public sealed partial class ToolExecutionStartToolDescription
{
    /// <summary>MCP Apps metadata for UI resource association.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("_meta")]
    public ToolExecutionStartToolDescriptionMeta? Meta { get; set; }

    /// <summary>Tool description.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("description")]
    public string? Description { get; set; }

    /// <summary>Tool name.</summary>
    [JsonPropertyName("name")]
    public required string Name { get; set; }
}

/// <summary>Error details when the tool execution failed.</summary>
/// <remarks>Nested data type for <c>ToolExecutionCompleteError</c>.</remarks>
public sealed partial class ToolExecutionCompleteError
{
    /// <summary>Machine-readable error code.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("code")]
    public string? Code { get; set; }

    /// <summary>Human-readable error message.</summary>
    [JsonPropertyName("message")]
    public required string Message { get; set; }

    /// <summary>What the user must do to recover, when the runtime knows of an action. Set on sandbox policy denials, where `message` names the rule that blocked the call but never the client affordance that relaxes it.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("remediation")]
    public RemediationAction? Remediation { get; set; }
}

/// <summary>Binary result returned by a tool for the model.</summary>
/// <remarks>Nested data type for <c>PersistedBinaryImage</c>.</remarks>
public sealed partial class PersistedBinaryImage
{
    /// <summary>Base64-encoded binary data.</summary>
    [Base64String]
    [JsonPropertyName("data")]
    public required string Data { get; set; }

    /// <summary>Human-readable description of the binary data.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("description")]
    public string? Description { get; set; }

    /// <summary>Optional metadata from the producing tool.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("metadata")]
    public IDictionary<string, JsonElement>? Metadata { get; set; }

    /// <summary>MIME type of the binary data.</summary>
    [JsonPropertyName("mimeType")]
    public required string MimeType { get; set; }

    /// <summary>Binary result type discriminator. Use "image" for images and "resource" for other binary data.</summary>
    [JsonPropertyName("type")]
    public required PersistedBinaryImageType Type { get; set; }
}

/// <summary>A binary result whose data was omitted from persistence due to the inline size limit.</summary>
/// <remarks>Nested data type for <c>OmittedBinaryResult</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
public sealed partial class OmittedBinaryResult
{
    /// <summary>Decoded byte length of the omitted binary data.</summary>
    [JsonPropertyName("byteLength")]
    public required long ByteLength { get; set; }

    /// <summary>Human-readable description of the binary data.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("description")]
    public string? Description { get; set; }

    /// <summary>Optional metadata from the producing tool.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("metadata")]
    public IDictionary<string, JsonElement>? Metadata { get; set; }

    /// <summary>MIME type of the omitted binary data.</summary>
    [JsonPropertyName("mimeType")]
    public required string MimeType { get; set; }

    /// <summary>Why the binary data is absent: it exceeded the inline size limit, or its asset was unavailable.</summary>
    [JsonPropertyName("omittedReason")]
    public required OmittedBinaryOmittedReason OmittedReason { get; set; }

    /// <summary>Binary result type discriminator. Use "image" for images and "resource" for other binary data.</summary>
    [JsonPropertyName("type")]
    public required OmittedBinaryType Type { get; set; }
}

/// <summary>A reference to binary data persisted once on a session.binary_asset event and shared by id.</summary>
/// <remarks>Nested data type for <c>BinaryAssetReference</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
public sealed partial class BinaryAssetReference
{
    /// <summary>Content-addressed id of the session.binary_asset event that holds this binary's bytes (e.g. "sha256:...").</summary>
    [JsonPropertyName("assetId")]
    public required string AssetId { get; set; }

    /// <summary>Decoded byte length of the referenced binary data.</summary>
    [JsonPropertyName("byteLength")]
    public required long ByteLength { get; set; }

    /// <summary>Human-readable description of the binary data.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("description")]
    public string? Description { get; set; }

    /// <summary>Optional metadata from the producing tool.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("metadata")]
    public IDictionary<string, JsonElement>? Metadata { get; set; }

    /// <summary>MIME type of the referenced binary data.</summary>
    [JsonPropertyName("mimeType")]
    public required string MimeType { get; set; }

    /// <summary>Binary result type discriminator. Use "image" for images and "resource" for other binary data.</summary>
    [JsonPropertyName("type")]
    public required BinaryAssetReferenceType Type { get; set; }
}

/// <summary>A model-facing binary result as persisted: full inline data, a size-omitted marker, or a deduplicated asset reference.</summary>
/// <remarks>JSON union data type for <c>PersistedBinaryResult</c>.</remarks>
[JsonConverter(typeof(Converter))]
public sealed partial class PersistedBinaryResult
{
    /// <summary>Gets the value when this instance contains <see cref="PersistedBinaryImage"/>.</summary>
    public PersistedBinaryImage? PersistedBinaryImage { get; }

    /// <summary>Gets the value when this instance contains <see cref="OmittedBinaryResult"/>.</summary>
    public OmittedBinaryResult? OmittedBinaryResult { get; }

    /// <summary>Gets the value when this instance contains <see cref="BinaryAssetReference"/>.</summary>
    public BinaryAssetReference? BinaryAssetReference { get; }

    /// <summary>Initializes a new instance of the <see cref="PersistedBinaryResult"/> class from <see cref="PersistedBinaryImage"/>.</summary>
    public PersistedBinaryResult(PersistedBinaryImage value)
    {
        ArgumentNullException.ThrowIfNull(value);
        PersistedBinaryImage = value;
    }

    /// <summary>Converts <see cref="PersistedBinaryImage"/> to <see cref="PersistedBinaryResult"/>.</summary>
    public static implicit operator PersistedBinaryResult(PersistedBinaryImage value) => new(value);

    /// <summary>Initializes a new instance of the <see cref="PersistedBinaryResult"/> class from <see cref="OmittedBinaryResult"/>.</summary>
    public PersistedBinaryResult(OmittedBinaryResult value)
    {
        ArgumentNullException.ThrowIfNull(value);
        OmittedBinaryResult = value;
    }

    /// <summary>Converts <see cref="OmittedBinaryResult"/> to <see cref="PersistedBinaryResult"/>.</summary>
    public static implicit operator PersistedBinaryResult(OmittedBinaryResult value) => new(value);

    /// <summary>Initializes a new instance of the <see cref="PersistedBinaryResult"/> class from <see cref="BinaryAssetReference"/>.</summary>
    public PersistedBinaryResult(BinaryAssetReference value)
    {
        ArgumentNullException.ThrowIfNull(value);
        BinaryAssetReference = value;
    }

    /// <summary>Converts <see cref="BinaryAssetReference"/> to <see cref="PersistedBinaryResult"/>.</summary>
    public static implicit operator PersistedBinaryResult(BinaryAssetReference value) => new(value);

    /// <summary>Provides a <see cref="JsonConverter{PersistedBinaryResult}"/> for serializing <see cref="PersistedBinaryResult"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<PersistedBinaryResult>
    {
        /// <inheritdoc />
        public override PersistedBinaryResult Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            if (reader.TokenType == JsonTokenType.Null)
            {
                throw new JsonException("Expected JSON object for PersistedBinaryResult.");
            }

            using var document = JsonDocument.ParseValue(ref reader);
            var element = document.RootElement;
            if (element.ValueKind == JsonValueKind.Object && element.TryGetProperty("data", out _) && !element.TryGetProperty("assetId", out _) && !element.TryGetProperty("byteLength", out _) && !element.TryGetProperty("omittedReason", out _))
            {
                var persistedBinaryImage = JsonSerializer.Deserialize(element, SessionEventsJsonContext.Default.PersistedBinaryImage);
                return persistedBinaryImage is null ? throw new JsonException("Expected PersistedBinaryImage value.") : new PersistedBinaryResult(persistedBinaryImage);
            }
            if (element.ValueKind == JsonValueKind.Object && element.TryGetProperty("omittedReason", out _) && !element.TryGetProperty("assetId", out _) && !element.TryGetProperty("data", out _))
            {
                var omittedBinaryResult = JsonSerializer.Deserialize(element, SessionEventsJsonContext.Default.OmittedBinaryResult);
                return omittedBinaryResult is null ? throw new JsonException("Expected OmittedBinaryResult value.") : new PersistedBinaryResult(omittedBinaryResult);
            }
            if (element.ValueKind == JsonValueKind.Object && element.TryGetProperty("assetId", out _) && !element.TryGetProperty("data", out _) && !element.TryGetProperty("omittedReason", out _))
            {
                var binaryAssetReference = JsonSerializer.Deserialize(element, SessionEventsJsonContext.Default.BinaryAssetReference);
                return binaryAssetReference is null ? throw new JsonException("Expected BinaryAssetReference value.") : new PersistedBinaryResult(binaryAssetReference);
            }

            throw new JsonException("JSON value did not match any PersistedBinaryResult variant.");
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, PersistedBinaryResult value, JsonSerializerOptions options)
        {
            if (value.PersistedBinaryImage is { } persistedBinaryImage)
            {
                JsonSerializer.Serialize(writer, persistedBinaryImage, SessionEventsJsonContext.Default.PersistedBinaryImage);
                return;
            }
            if (value.OmittedBinaryResult is { } omittedBinaryResult)
            {
                JsonSerializer.Serialize(writer, omittedBinaryResult, SessionEventsJsonContext.Default.OmittedBinaryResult);
                return;
            }
            if (value.BinaryAssetReference is { } binaryAssetReference)
            {
                JsonSerializer.Serialize(writer, binaryAssetReference, SessionEventsJsonContext.Default.BinaryAssetReference);
                return;
            }

            throw new JsonException("No PersistedBinaryResult variant value is set.");
        }
    }
}

/// <summary>A source supplied by a tool that should be made available to the model as citable content.</summary>
/// <remarks>Nested data type for <c>CitableSource</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
public sealed partial class CitableSource
{
    /// <summary>The source text made available to the model as citable content.</summary>
    [JsonPropertyName("content")]
    public required string Content { get; set; }

    /// <summary>Stable identifier for this source within the tool result. Used for deduplication and may be used by future provider integrations to correlate response citations back to the originating source.</summary>
    [JsonPropertyName("id")]
    public required string Id { get; set; }

    /// <summary>File path relative to the agent's workspace root, when the source is a file.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("path")]
    public string? Path { get; set; }

    /// <summary>Human-readable title of the source.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("title")]
    public string? Title { get; set; }

    /// <summary>URL of the source, when it is a web resource.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("url")]
    public string? Url { get; set; }
}

/// <summary>Plain text content block.</summary>
/// <remarks>The <c>text</c> variant of <see cref="ToolExecutionCompleteContent"/>.</remarks>
public sealed partial class ToolExecutionCompleteContentText : ToolExecutionCompleteContent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "text";

    /// <summary>The text content.</summary>
    [JsonPropertyName("text")]
    public required string Text { get; set; }
}

/// <summary>Deprecated for shell command exit metadata. Use ToolExecutionCompleteContentShellExit instead.</summary>
/// <remarks>The <c>terminal</c> variant of <see cref="ToolExecutionCompleteContent"/>.</remarks>
[EditorBrowsable(EditorBrowsableState.Never)]
#if NET5_0_OR_GREATER
[Obsolete("This member is deprecated and will be removed in a future version.", DiagnosticId = "GHCP001")]
#endif
public sealed partial class ToolExecutionCompleteContentTerminal : ToolExecutionCompleteContent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "terminal";

    /// <summary>Working directory where the command was executed.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("cwd")]
    public string? Cwd { get; set; }

    /// <summary>Process exit code, if the command has completed.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("exitCode")]
    public long? ExitCode { get; set; }

    /// <summary>Terminal/shell output text.</summary>
    [JsonPropertyName("text")]
    public required string Text { get; set; }
}

/// <summary>Shell command exit metadata with optional output preview.</summary>
/// <remarks>The <c>shell_exit</c> variant of <see cref="ToolExecutionCompleteContent"/>.</remarks>
public sealed partial class ToolExecutionCompleteContentShellExit : ToolExecutionCompleteContent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "shell_exit";

    /// <summary>Working directory where the shell command was executed.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("cwd")]
    public string? Cwd { get; set; }

    /// <summary>Exit code from the completed shell command.</summary>
    [JsonPropertyName("exitCode")]
    public required long ExitCode { get; set; }

    /// <summary>Path reported in the shell session's filesystem namespace when shell output exceeded the configured large-output threshold.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("outputFilePath")]
    public string? OutputFilePath { get; set; }

    /// <summary>Output associated with this shell command, if available. May be partial, truncated, or a preview; not guaranteed to be full output.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("outputPreview")]
    public string? OutputPreview { get; set; }

    /// <summary>Whether outputPreview is known to be incomplete or truncated.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("outputTruncated")]
    public bool? OutputTruncated { get; set; }

    /// <summary>Shell id, as assigned by Copilot runtime.</summary>
    [JsonPropertyName("shellId")]
    public required string ShellId { get; set; }
}

/// <summary>Image content block with base64-encoded data.</summary>
/// <remarks>The <c>image</c> variant of <see cref="ToolExecutionCompleteContent"/>.</remarks>
public sealed partial class ToolExecutionCompleteContentImage : ToolExecutionCompleteContent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "image";

    /// <summary>Base64-encoded image data.</summary>
    [Base64String]
    [JsonPropertyName("data")]
    public required string Data { get; set; }

    /// <summary>MIME type of the image (e.g., image/png, image/jpeg).</summary>
    [JsonPropertyName("mimeType")]
    public required string MimeType { get; set; }
}

/// <summary>Audio content block with base64-encoded data.</summary>
/// <remarks>The <c>audio</c> variant of <see cref="ToolExecutionCompleteContent"/>.</remarks>
public sealed partial class ToolExecutionCompleteContentAudio : ToolExecutionCompleteContent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "audio";

    /// <summary>Base64-encoded audio data.</summary>
    [Base64String]
    [JsonPropertyName("data")]
    public required string Data { get; set; }

    /// <summary>MIME type of the audio (e.g., audio/wav, audio/mpeg).</summary>
    [JsonPropertyName("mimeType")]
    public required string MimeType { get; set; }
}

/// <summary>Icon image for a resource.</summary>
/// <remarks>Nested data type for <c>ToolExecutionCompleteContentResourceLinkIcon</c>.</remarks>
public sealed partial class ToolExecutionCompleteContentResourceLinkIcon
{
    /// <summary>MIME type of the icon image.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("mimeType")]
    public string? MimeType { get; set; }

    /// <summary>Available icon sizes (e.g., ['16x16', '32x32']).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("sizes")]
    public string[]? Sizes { get; set; }

    /// <summary>URL or path to the icon image.</summary>
    [JsonPropertyName("src")]
    public required string Src { get; set; }

    /// <summary>Theme variant this icon is intended for.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("theme")]
    public ToolExecutionCompleteContentResourceLinkIconTheme? Theme { get; set; }
}

/// <summary>Resource link content block referencing an external resource.</summary>
/// <remarks>The <c>resource_link</c> variant of <see cref="ToolExecutionCompleteContent"/>.</remarks>
public sealed partial class ToolExecutionCompleteContentResourceLink : ToolExecutionCompleteContent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "resource_link";

    /// <summary>Human-readable description of the resource.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("description")]
    public string? Description { get; set; }

    /// <summary>Icons associated with this resource.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("icons")]
    public ToolExecutionCompleteContentResourceLinkIcon[]? Icons { get; set; }

    /// <summary>MIME type of the resource content.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("mimeType")]
    public string? MimeType { get; set; }

    /// <summary>Resource name identifier.</summary>
    [JsonPropertyName("name")]
    public required string Name { get; set; }

    /// <summary>Size of the resource in bytes.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("size")]
    public long? Size { get; set; }

    /// <summary>Human-readable display title for the resource.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("title")]
    public string? Title { get; set; }

    /// <summary>URI identifying the resource.</summary>
    [JsonPropertyName("uri")]
    public required string Uri { get; set; }
}

/// <summary>Embedded text resource contents identified by a URI, with an optional MIME type and a text payload.</summary>
/// <remarks>Nested data type for <c>EmbeddedTextResourceContents</c>.</remarks>
public sealed partial class EmbeddedTextResourceContents
{
    /// <summary>MIME type of the text content.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("mimeType")]
    public string? MimeType { get; set; }

    /// <summary>Text content of the resource.</summary>
    [JsonPropertyName("text")]
    public required string Text { get; set; }

    /// <summary>URI identifying the resource.</summary>
    [JsonPropertyName("uri")]
    public required string Uri { get; set; }
}

/// <summary>Embedded binary resource contents identified by a URI, with an optional MIME type and a base64-encoded blob.</summary>
/// <remarks>Nested data type for <c>EmbeddedBlobResourceContents</c>.</remarks>
public sealed partial class EmbeddedBlobResourceContents
{
    /// <summary>Base64-encoded binary content of the resource.</summary>
    [Base64String]
    [JsonPropertyName("blob")]
    public required string Blob { get; set; }

    /// <summary>MIME type of the blob content.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("mimeType")]
    public string? MimeType { get; set; }

    /// <summary>URI identifying the resource.</summary>
    [JsonPropertyName("uri")]
    public required string Uri { get; set; }
}

/// <summary>The embedded resource contents, either text or base64-encoded binary.</summary>
/// <remarks>JSON union data type for <c>ToolExecutionCompleteContentResourceDetails</c>.</remarks>
[JsonConverter(typeof(Converter))]
public sealed partial class ToolExecutionCompleteContentResourceDetails
{
    /// <summary>Gets the value when this instance contains <see cref="EmbeddedTextResourceContents"/>.</summary>
    public EmbeddedTextResourceContents? EmbeddedTextResourceContents { get; }

    /// <summary>Gets the value when this instance contains <see cref="EmbeddedBlobResourceContents"/>.</summary>
    public EmbeddedBlobResourceContents? EmbeddedBlobResourceContents { get; }

    /// <summary>Initializes a new instance of the <see cref="ToolExecutionCompleteContentResourceDetails"/> class from <see cref="EmbeddedTextResourceContents"/>.</summary>
    public ToolExecutionCompleteContentResourceDetails(EmbeddedTextResourceContents value)
    {
        ArgumentNullException.ThrowIfNull(value);
        EmbeddedTextResourceContents = value;
    }

    /// <summary>Converts <see cref="EmbeddedTextResourceContents"/> to <see cref="ToolExecutionCompleteContentResourceDetails"/>.</summary>
    public static implicit operator ToolExecutionCompleteContentResourceDetails(EmbeddedTextResourceContents value) => new(value);

    /// <summary>Initializes a new instance of the <see cref="ToolExecutionCompleteContentResourceDetails"/> class from <see cref="EmbeddedBlobResourceContents"/>.</summary>
    public ToolExecutionCompleteContentResourceDetails(EmbeddedBlobResourceContents value)
    {
        ArgumentNullException.ThrowIfNull(value);
        EmbeddedBlobResourceContents = value;
    }

    /// <summary>Converts <see cref="EmbeddedBlobResourceContents"/> to <see cref="ToolExecutionCompleteContentResourceDetails"/>.</summary>
    public static implicit operator ToolExecutionCompleteContentResourceDetails(EmbeddedBlobResourceContents value) => new(value);

    /// <summary>Provides a <see cref="JsonConverter{ToolExecutionCompleteContentResourceDetails}"/> for serializing <see cref="ToolExecutionCompleteContentResourceDetails"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<ToolExecutionCompleteContentResourceDetails>
    {
        /// <inheritdoc />
        public override ToolExecutionCompleteContentResourceDetails Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            if (reader.TokenType == JsonTokenType.Null)
            {
                throw new JsonException("Expected JSON object for ToolExecutionCompleteContentResourceDetails.");
            }

            using var document = JsonDocument.ParseValue(ref reader);
            var element = document.RootElement;
            if (element.ValueKind == JsonValueKind.Object && element.TryGetProperty("text", out _) && !element.TryGetProperty("blob", out _))
            {
                var embeddedTextResourceContents = JsonSerializer.Deserialize(element, SessionEventsJsonContext.Default.EmbeddedTextResourceContents);
                return embeddedTextResourceContents is null ? throw new JsonException("Expected EmbeddedTextResourceContents value.") : new ToolExecutionCompleteContentResourceDetails(embeddedTextResourceContents);
            }
            if (element.ValueKind == JsonValueKind.Object && element.TryGetProperty("blob", out _) && !element.TryGetProperty("text", out _))
            {
                var embeddedBlobResourceContents = JsonSerializer.Deserialize(element, SessionEventsJsonContext.Default.EmbeddedBlobResourceContents);
                return embeddedBlobResourceContents is null ? throw new JsonException("Expected EmbeddedBlobResourceContents value.") : new ToolExecutionCompleteContentResourceDetails(embeddedBlobResourceContents);
            }

            throw new JsonException("JSON value did not match any ToolExecutionCompleteContentResourceDetails variant.");
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, ToolExecutionCompleteContentResourceDetails value, JsonSerializerOptions options)
        {
            if (value.EmbeddedTextResourceContents is { } embeddedTextResourceContents)
            {
                JsonSerializer.Serialize(writer, embeddedTextResourceContents, SessionEventsJsonContext.Default.EmbeddedTextResourceContents);
                return;
            }
            if (value.EmbeddedBlobResourceContents is { } embeddedBlobResourceContents)
            {
                JsonSerializer.Serialize(writer, embeddedBlobResourceContents, SessionEventsJsonContext.Default.EmbeddedBlobResourceContents);
                return;
            }

            throw new JsonException("No ToolExecutionCompleteContentResourceDetails variant value is set.");
        }
    }
}

/// <summary>Embedded resource content block with inline text or binary data.</summary>
/// <remarks>The <c>resource</c> variant of <see cref="ToolExecutionCompleteContent"/>.</remarks>
public sealed partial class ToolExecutionCompleteContentResource : ToolExecutionCompleteContent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "resource";

    /// <summary>The embedded resource contents, either text or base64-encoded binary.</summary>
    [JsonPropertyName("resource")]
    public required ToolExecutionCompleteContentResourceDetails Resource { get; set; }
}

/// <summary>A content block within a tool result, which may be text, terminal output, image, audio, or a resource.</summary>
/// <remarks>Polymorphic base type discriminated by <c>type</c>.</remarks>
[JsonPolymorphic(
    TypeDiscriminatorPropertyName = "type",
    UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FallBackToBaseType)]
[JsonDerivedType(typeof(ToolExecutionCompleteContentText), "text")]
[JsonDerivedType(typeof(ToolExecutionCompleteContentTerminal), "terminal")]
[JsonDerivedType(typeof(ToolExecutionCompleteContentShellExit), "shell_exit")]
[JsonDerivedType(typeof(ToolExecutionCompleteContentImage), "image")]
[JsonDerivedType(typeof(ToolExecutionCompleteContentAudio), "audio")]
[JsonDerivedType(typeof(ToolExecutionCompleteContentResourceLink), "resource_link")]
[JsonDerivedType(typeof(ToolExecutionCompleteContentResource), "resource")]
public partial class ToolExecutionCompleteContent
{
    /// <summary>The type discriminator.</summary>
    [JsonPropertyName("type")]
    public virtual string Type { get; set; } = string.Empty;
}


/// <summary>CSP domain allowlists for an MCP Apps UI resource, including connect, resource, frame, and base URI domains.</summary>
/// <remarks>Nested data type for <c>ToolExecutionCompleteUIResourceMetaUICsp</c>.</remarks>
public sealed partial class ToolExecutionCompleteUIResourceMetaUICsp
{
    /// <summary>Domains the UI resource may use as document base URIs.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("baseUriDomains")]
    public string[]? BaseUriDomains { get; set; }

    /// <summary>Domains the UI resource may connect to.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("connectDomains")]
    public string[]? ConnectDomains { get; set; }

    /// <summary>Domains the UI resource may embed as nested frames.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("frameDomains")]
    public string[]? FrameDomains { get; set; }

    /// <summary>Domains from which the UI resource may load scripts, styles, images, and other resources.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("resourceDomains")]
    public string[]? ResourceDomains { get; set; }
}

/// <summary>Marker object for camera permission on an MCP Apps UI resource.</summary>
/// <remarks>Nested data type for <c>ToolExecutionCompleteUIResourceMetaUIPermissionsCamera</c>.</remarks>
public sealed partial class ToolExecutionCompleteUIResourceMetaUIPermissionsCamera
{
}

/// <summary>Marker object for clipboard-write permission on an MCP Apps UI resource.</summary>
/// <remarks>Nested data type for <c>ToolExecutionCompleteUIResourceMetaUIPermissionsClipboardWrite</c>.</remarks>
public sealed partial class ToolExecutionCompleteUIResourceMetaUIPermissionsClipboardWrite
{
}

/// <summary>Marker object for geolocation permission on an MCP Apps UI resource.</summary>
/// <remarks>Nested data type for <c>ToolExecutionCompleteUIResourceMetaUIPermissionsGeolocation</c>.</remarks>
public sealed partial class ToolExecutionCompleteUIResourceMetaUIPermissionsGeolocation
{
}

/// <summary>Marker object for microphone permission on an MCP Apps UI resource.</summary>
/// <remarks>Nested data type for <c>ToolExecutionCompleteUIResourceMetaUIPermissionsMicrophone</c>.</remarks>
public sealed partial class ToolExecutionCompleteUIResourceMetaUIPermissionsMicrophone
{
}

/// <summary>Browser permission metadata for an MCP Apps UI resource, including camera, microphone, geolocation, and clipboard-write.</summary>
/// <remarks>Nested data type for <c>ToolExecutionCompleteUIResourceMetaUIPermissions</c>.</remarks>
public sealed partial class ToolExecutionCompleteUIResourceMetaUIPermissions
{
    /// <summary>Marker object for camera permission on an MCP Apps UI resource.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("camera")]
    public ToolExecutionCompleteUIResourceMetaUIPermissionsCamera? Camera { get; set; }

    /// <summary>Marker object for clipboard-write permission on an MCP Apps UI resource.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("clipboardWrite")]
    public ToolExecutionCompleteUIResourceMetaUIPermissionsClipboardWrite? ClipboardWrite { get; set; }

    /// <summary>Marker object for geolocation permission on an MCP Apps UI resource.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("geolocation")]
    public ToolExecutionCompleteUIResourceMetaUIPermissionsGeolocation? Geolocation { get; set; }

    /// <summary>Marker object for microphone permission on an MCP Apps UI resource.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("microphone")]
    public ToolExecutionCompleteUIResourceMetaUIPermissionsMicrophone? Microphone { get; set; }
}

/// <summary>MCP Apps UI resource metadata for a completed tool result, including CSP, permissions, domain, and border preference.</summary>
/// <remarks>Nested data type for <c>ToolExecutionCompleteUIResourceMetaUI</c>.</remarks>
public sealed partial class ToolExecutionCompleteUIResourceMetaUI
{
    /// <summary>CSP domain allowlists for an MCP Apps UI resource, including connect, resource, frame, and base URI domains.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("csp")]
    public ToolExecutionCompleteUIResourceMetaUICsp? Csp { get; set; }

    /// <summary>Optional dedicated origin for the rendered MCP Apps UI resource.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("domain")]
    public string? Domain { get; set; }

    /// <summary>Browser permission metadata for an MCP Apps UI resource, including camera, microphone, geolocation, and clipboard-write.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("permissions")]
    public ToolExecutionCompleteUIResourceMetaUIPermissions? Permissions { get; set; }

    /// <summary>Whether the host should render a border around the MCP Apps UI resource.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("prefersBorder")]
    public bool? PrefersBorder { get; set; }
}

/// <summary>Resource-level UI metadata (CSP, permissions, visual preferences).</summary>
/// <remarks>Nested data type for <c>ToolExecutionCompleteUIResourceMeta</c>.</remarks>
public sealed partial class ToolExecutionCompleteUIResourceMeta
{
    /// <summary>MCP Apps UI resource metadata for a completed tool result, including CSP, permissions, domain, and border preference.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("ui")]
    public ToolExecutionCompleteUIResourceMetaUI? Ui { get; set; }
}

/// <summary>MCP Apps UI resource content for rendering in a sandboxed iframe.</summary>
/// <remarks>Nested data type for <c>ToolExecutionCompleteUIResource</c>.</remarks>
public sealed partial class ToolExecutionCompleteUIResource
{
    /// <summary>Resource-level UI metadata (CSP, permissions, visual preferences).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("_meta")]
    public ToolExecutionCompleteUIResourceMeta? Meta { get; set; }

    /// <summary>Base64-encoded HTML content.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("blob")]
    public string? Blob { get; set; }

    /// <summary>MIME type of the content.</summary>
    [JsonPropertyName("mimeType")]
    public required string MimeType { get; set; }

    /// <summary>HTML content as a string.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("text")]
    public string? Text { get; set; }

    /// <summary>The ui:// URI of the resource.</summary>
    [JsonPropertyName("uri")]
    public required string Uri { get; set; }
}

/// <summary>Tool execution result on success.</summary>
/// <remarks>Nested data type for <c>ToolExecutionCompleteResult</c>.</remarks>
public sealed partial class ToolExecutionCompleteResult
{
    /// <summary>Model-facing binary results (base64 inline or size-omitted markers) sent to the LLM for this tool call.</summary>
    [Experimental(Diagnostics.Experimental)]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("binaryResultsForLlm")]
    public PersistedBinaryResult[]? BinaryResultsForLlm { get; set; }

    /// <summary>Provider-neutral source material this tool makes available to the model as citable content. Persisted so it survives session resume. Experimental.</summary>
    [Experimental(Diagnostics.Experimental)]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("citableSources")]
    public CitableSource[]? CitableSources { get; set; }

    /// <summary>Concise tool result text sent to the LLM for chat completion, potentially truncated for token efficiency.</summary>
    [JsonPropertyName("content")]
    public required string Content { get; set; }

    /// <summary>Structured content blocks (text, images, audio, resources) returned by the tool in their native format.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("contents")]
    public ToolExecutionCompleteContent[]? Contents { get; set; }

    /// <summary>Full detailed tool result for UI/timeline display, preserving complete content such as diffs. Falls back to content when absent.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("detailedContent")]
    public string? DetailedContent { get; set; }

    /// <summary>FIDES IFC label projected from tool ingress metadata (MCP `CallToolResult._meta` or synthesized built-in ingress labels) — persisted as `{ ifc: ... }` (only the `ifc` key, not the whole `_meta`). Persisted so the FIDES IFC label survives session resume: the engine rehydrates accumulated taint by replaying these on load. Populated for ingress sources when FIDES IFC is on. Experimental.</summary>
    [Experimental(Diagnostics.Experimental)]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("mcpMeta")]
    public JsonElement? McpMeta { get; set; }

    /// <summary>Structured content (arbitrary JSON) returned verbatim by the MCP tool.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("structuredContent")]
    public JsonElement? StructuredContent { get; set; }

    /// <summary>MCP Apps UI resource content for rendering in a sandboxed iframe.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("uiResource")]
    public ToolExecutionCompleteUIResource? UiResource { get; set; }
}

/// <summary>MCP Apps tool `_meta.ui` resource URI and visibility captured on `tool.execution_complete`.</summary>
/// <remarks>Nested data type for <c>ToolExecutionCompleteToolDescriptionMetaUI</c>.</remarks>
public sealed partial class ToolExecutionCompleteToolDescriptionMetaUI
{
    /// <summary>URI of the UI resource.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("resourceUri")]
    public string? ResourceUri { get; set; }

    /// <summary>Who can access this tool.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("visibility")]
    public ToolExecutionCompleteToolDescriptionMetaUIVisibility[]? Visibility { get; set; }
}

/// <summary>MCP Apps metadata for UI resource association.</summary>
/// <remarks>Nested data type for <c>ToolExecutionCompleteToolDescriptionMeta</c>.</remarks>
public sealed partial class ToolExecutionCompleteToolDescriptionMeta
{
    /// <summary>MCP Apps tool `_meta.ui` resource URI and visibility captured on `tool.execution_complete`.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("ui")]
    public ToolExecutionCompleteToolDescriptionMetaUI? Ui { get; set; }
}

/// <summary>Tool definition metadata, present for MCP tools with MCP Apps support.</summary>
/// <remarks>Nested data type for <c>ToolExecutionCompleteToolDescription</c>.</remarks>
public sealed partial class ToolExecutionCompleteToolDescription
{
    /// <summary>MCP Apps metadata for UI resource association.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("_meta")]
    public ToolExecutionCompleteToolDescriptionMeta? Meta { get; set; }

    /// <summary>Tool description.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("description")]
    public string? Description { get; set; }

    /// <summary>Tool name.</summary>
    [JsonPropertyName("name")]
    public required string Name { get; set; }
}

/// <summary>Error details when the hook failed.</summary>
/// <remarks>Nested data type for <c>HookEndError</c>.</remarks>
public sealed partial class HookEndError
{
    /// <summary>Human-readable error message.</summary>
    [JsonPropertyName("message")]
    public required string Message { get; set; }

    /// <summary>Source label of the hook that errored (e.g. the plugin it was loaded from), when known.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("source")]
    public string? Source { get; set; }

    /// <summary>Error stack trace, when available.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("stack")]
    public string? Stack { get; set; }
}

/// <summary>Metadata about the prompt template and its construction.</summary>
/// <remarks>Nested data type for <c>SystemMessageMetadata</c>.</remarks>
public sealed partial class SystemMessageMetadata
{
    /// <summary>Version identifier of the prompt template used.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("promptVersion")]
    public string? PromptVersion { get; set; }

    /// <summary>Template variables used when constructing the prompt.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("variables")]
    public IDictionary<string, JsonElement>? Variables { get; set; }
}

/// <summary>System notification metadata for a background agent that completed or failed, including agent ID, type, status, description, and prompt.</summary>
/// <remarks>The <c>agent_completed</c> variant of <see cref="SystemNotification"/>.</remarks>
public sealed partial class SystemNotificationAgentCompleted : SystemNotification
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "agent_completed";

    /// <summary>Unique task identifier.</summary>
    [JsonPropertyName("agentId")]
    public required string AgentId { get; set; }

    /// <summary>Type of the agent (e.g., explore, task, general-purpose).</summary>
    [JsonPropertyName("agentType")]
    public required string AgentType { get; set; }

    /// <summary>Human-readable description of the agent task.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("description")]
    public string? Description { get; set; }

    /// <summary>Friendly, non-unique name intended for display.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("displayName")]
    public string? DisplayName { get; set; }

    /// <summary>The full prompt given to the background agent.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("prompt")]
    public string? Prompt { get; set; }

    /// <summary>Whether the agent completed successfully or failed.</summary>
    [JsonPropertyName("status")]
    public required SystemNotificationAgentCompletedStatus Status { get; set; }
}

/// <summary>System notification metadata for a background agent that became idle, including agent ID, type, and description.</summary>
/// <remarks>The <c>agent_idle</c> variant of <see cref="SystemNotification"/>.</remarks>
public sealed partial class SystemNotificationAgentIdle : SystemNotification
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "agent_idle";

    /// <summary>Unique task identifier.</summary>
    [JsonPropertyName("agentId")]
    public required string AgentId { get; set; }

    /// <summary>Type of the agent (e.g., explore, task, general-purpose).</summary>
    [JsonPropertyName("agentType")]
    public required string AgentType { get; set; }

    /// <summary>Human-readable description of the agent task.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("description")]
    public string? Description { get; set; }

    /// <summary>Friendly, non-unique name intended for display.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("displayName")]
    public string? DisplayName { get; set; }
}

/// <summary>System notification metadata for a new inbox message, including entry ID, sender details, and summary.</summary>
/// <remarks>The <c>new_inbox_message</c> variant of <see cref="SystemNotification"/>.</remarks>
public sealed partial class SystemNotificationNewInboxMessage : SystemNotification
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "new_inbox_message";

    /// <summary>Unique identifier of the inbox entry.</summary>
    [JsonPropertyName("entryId")]
    public required string EntryId { get; set; }

    /// <summary>Human-readable name of the sender.</summary>
    [JsonPropertyName("senderName")]
    public required string SenderName { get; set; }

    /// <summary>Category of the sender (e.g., sidekick-agent, plugin, hook).</summary>
    [JsonPropertyName("senderType")]
    public required string SenderType { get; set; }

    /// <summary>Short summary shown before the agent decides whether to read the inbox.</summary>
    [JsonPropertyName("summary")]
    public required string Summary { get; set; }
}

/// <summary>System notification metadata for a shell session that completed, including shell ID, optional exit code, and description.</summary>
/// <remarks>The <c>shell_completed</c> variant of <see cref="SystemNotification"/>.</remarks>
public sealed partial class SystemNotificationShellCompleted : SystemNotification
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "shell_completed";

    /// <summary>Human-readable description of the command.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("description")]
    public string? Description { get; set; }

    /// <summary>Exit code of the shell command, if available.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("exitCode")]
    public long? ExitCode { get; set; }

    /// <summary>Unique identifier of the shell session.</summary>
    [JsonPropertyName("shellId")]
    public required string ShellId { get; set; }
}

/// <summary>System notification metadata for a detached shell session that completed, including shell ID and description.</summary>
/// <remarks>The <c>shell_detached_completed</c> variant of <see cref="SystemNotification"/>.</remarks>
public sealed partial class SystemNotificationShellDetachedCompleted : SystemNotification
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "shell_detached_completed";

    /// <summary>Human-readable description of the command.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("description")]
    public string? Description { get; set; }

    /// <summary>Unique identifier of the detached shell session.</summary>
    [JsonPropertyName("shellId")]
    public required string ShellId { get; set; }
}

/// <summary>System notification metadata for an instruction file discovered during tool access, including source, trigger file, and tool.</summary>
/// <remarks>The <c>instruction_discovered</c> variant of <see cref="SystemNotification"/>.</remarks>
public sealed partial class SystemNotificationInstructionDiscovered : SystemNotification
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "instruction_discovered";

    /// <summary>Human-readable label for the timeline (e.g., 'AGENTS.md from packages/billing/').</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("description")]
    public string? Description { get; set; }

    /// <summary>Relative path to the discovered instruction file.</summary>
    [JsonPropertyName("sourcePath")]
    public required string SourcePath { get; set; }

    /// <summary>Path of the file access that triggered discovery.</summary>
    [JsonPropertyName("triggerFile")]
    public required string TriggerFile { get; set; }

    /// <summary>Tool command that triggered discovery (currently always 'view').</summary>
    [JsonPropertyName("triggerTool")]
    public required string TriggerTool { get; set; }
}

/// <summary>System notification metadata for a factory execution attempt that reached a terminal state.</summary>
/// <remarks>The <c>factory_completed</c> variant of <see cref="SystemNotification"/>.</remarks>
public sealed partial class SystemNotificationFactoryCompleted : SystemNotification
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "factory_completed";

    /// <summary>Execution attempt that reached this terminal state.</summary>
    [JsonPropertyName("attempt")]
    public required long Attempt { get; set; }

    /// <summary>Consumed AI usage in nano-AIU.</summary>
    [JsonPropertyName("consumedNanoAiu")]
    public required long ConsumedNanoAiu { get; set; }

    /// <summary>Subagents consumed by the run across all attempts.</summary>
    [JsonPropertyName("consumedSubagents")]
    public required long ConsumedSubagents { get; set; }

    /// <summary>Accumulated active execution time in milliseconds.</summary>
    [JsonPropertyName("elapsedMs")]
    public required long ElapsedMs { get; set; }

    /// <summary>Persisted factory name.</summary>
    [JsonPropertyName("factoryName")]
    public required string FactoryName { get; set; }

    /// <summary>Machine-readable terminal failure details, when present.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("failure")]
    public JsonElement? Failure { get; set; }

    /// <summary>Bounded prompt-safe preview of the completed result.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MaxLength(256)]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("resultPreview")]
    public string? ResultPreview { get; set; }

    /// <summary>Actionable run_factory resume guidance for a resource-limit failure.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("retryGuidance")]
    public string? RetryGuidance { get; set; }

    /// <summary>Factory run identifier.</summary>
    [JsonPropertyName("runId")]
    public required string RunId { get; set; }

    /// <summary>Terminal status reached by this execution attempt.</summary>
    [JsonPropertyName("status")]
    public required SystemNotificationFactoryCompletedStatus Status { get; set; }
}

/// <summary>System notification metadata from an external host that does not match a runtime-owned notification kind.</summary>
/// <remarks>The <c>unclassified</c> variant of <see cref="SystemNotification"/>.</remarks>
public sealed partial class SystemNotificationUnclassified : SystemNotification
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "unclassified";

    /// <summary>Opaque metadata supplied by the external host, when present.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("metadata")]
    public JsonElement? Metadata { get; set; }
}

/// <summary>Structured metadata identifying what triggered this notification.</summary>
/// <remarks>Polymorphic base type discriminated by <c>type</c>.</remarks>
[JsonPolymorphic(
    TypeDiscriminatorPropertyName = "type",
    UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FallBackToBaseType)]
[JsonDerivedType(typeof(SystemNotificationAgentCompleted), "agent_completed")]
[JsonDerivedType(typeof(SystemNotificationAgentIdle), "agent_idle")]
[JsonDerivedType(typeof(SystemNotificationNewInboxMessage), "new_inbox_message")]
[JsonDerivedType(typeof(SystemNotificationShellCompleted), "shell_completed")]
[JsonDerivedType(typeof(SystemNotificationShellDetachedCompleted), "shell_detached_completed")]
[JsonDerivedType(typeof(SystemNotificationInstructionDiscovered), "instruction_discovered")]
[JsonDerivedType(typeof(SystemNotificationFactoryCompleted), "factory_completed")]
[JsonDerivedType(typeof(SystemNotificationUnclassified), "unclassified")]
public partial class SystemNotification
{
    /// <summary>The type discriminator.</summary>
    [JsonPropertyName("type")]
    public virtual string Type { get; set; } = string.Empty;
}


/// <summary>A parsed command identifier in a shell permission request, including whether it is read-only.</summary>
/// <remarks>Nested data type for <c>PermissionRequestShellCommand</c>.</remarks>
public sealed partial class PermissionRequestShellCommand
{
    /// <summary>Command identifier (e.g., executable name).</summary>
    [JsonPropertyName("identifier")]
    public required string Identifier { get; set; }

    /// <summary>Whether this command is read-only (no side effects).</summary>
    [JsonPropertyName("readOnly")]
    public required bool ReadOnly { get; set; }
}

/// <summary>A parsed shell command segment used for argument-aware managed policy matching.</summary>
/// <remarks>Nested data type for <c>PermissionRequestShellCommandSegment</c>.</remarks>
public sealed partial class PermissionRequestShellCommandSegment
{
    /// <summary>Full text of this command segment, including arguments.</summary>
    [JsonPropertyName("fullCommandText")]
    public required string FullCommandText { get; set; }

    /// <summary>Command identifier (e.g., executable name).</summary>
    [JsonPropertyName("identifier")]
    public required string Identifier { get; set; }
}

/// <summary>A URL that may be accessed by a command in a shell permission request.</summary>
/// <remarks>Nested data type for <c>PermissionRequestShellPossibleUrl</c>.</remarks>
public sealed partial class PermissionRequestShellPossibleUrl
{
    /// <summary>URL that may be accessed by the command.</summary>
    [JsonPropertyName("url")]
    public required string Url { get; set; }
}

/// <summary>Shell command permission request.</summary>
/// <remarks>The <c>shell</c> variant of <see cref="PermissionRequest"/>.</remarks>
public sealed partial class PermissionRequestShell : PermissionRequest
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "shell";

    /// <summary>Whether the UI can offer session-wide approval for this command pattern.</summary>
    [JsonPropertyName("canOfferSessionApproval")]
    public required bool CanOfferSessionApproval { get; set; }

    /// <summary>Parsed command identifiers found in the command text.</summary>
    [JsonPropertyName("commands")]
    public required PermissionRequestShellCommand[] Commands { get; set; }

    /// <summary>Parsed command segments, including arguments, used for managed policy matching.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("commandSegments")]
    public PermissionRequestShellCommandSegment[]? CommandSegments { get; set; }

    /// <summary>The complete shell command text to be executed.</summary>
    [JsonPropertyName("fullCommandText")]
    public required string FullCommandText { get; set; }

    /// <summary>Whether the command includes a file write redirection (e.g., &gt; or &gt;&gt;).</summary>
    [JsonPropertyName("hasWriteFileRedirection")]
    public required bool HasWriteFileRedirection { get; set; }

    /// <summary>Human-readable description of what the command intends to do.</summary>
    [JsonPropertyName("intention")]
    public required string Intention { get; set; }

    /// <inheritdoc />
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("managedApprovalRequired")]
    public override bool? ManagedApprovalRequired
    {
        get => base.ManagedApprovalRequired;
        set => base.ManagedApprovalRequired = value;
    }

    /// <summary>File paths that may be read or written by the command.</summary>
    [JsonPropertyName("possiblePaths")]
    public required string[] PossiblePaths { get; set; }

    /// <summary>URLs that may be accessed by the command.</summary>
    [JsonPropertyName("possibleUrls")]
    public required PermissionRequestShellPossibleUrl[] PossibleUrls { get; set; }

    /// <summary>True when the tool is asking to run this command outside the sandbox, either because the command detaches and cannot be sandboxed at all, or because a sandboxed run looked blocked (host opted in via sandbox.allowBypass). The model cannot ask for this; only the tool raises it. This is a request, not a grant: the command runs unsandboxed only if the user approves this permission request. Hosts should highlight the elevated risk in the approval UI.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("requestSandboxBypass")]
    public bool? RequestSandboxBypass { get; set; }

    /// <summary>What the tool tells the user about the bypass on offer: which policy rule blocked the call, or why it cannot be sandboxed. Only meaningful when requestSandboxBypass is true.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("requestSandboxBypassReason")]
    public string? RequestSandboxBypassReason { get; set; }

    /// <summary>Tool call ID that triggered this permission request.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("toolCallId")]
    public string? ToolCallId { get; set; }

    /// <summary>Optional warning message about risks of running this command.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("warning")]
    public string? Warning { get; set; }
}

/// <summary>File write permission request.</summary>
/// <remarks>The <c>write</c> variant of <see cref="PermissionRequest"/>.</remarks>
public sealed partial class PermissionRequestWrite : PermissionRequest
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "write";

    /// <summary>Whether the UI can offer session-wide approval for file write operations.</summary>
    [JsonPropertyName("canOfferSessionApproval")]
    public required bool CanOfferSessionApproval { get; set; }

    /// <summary>Unified diff showing the proposed changes.</summary>
    [JsonPropertyName("diff")]
    public required string Diff { get; set; }

    /// <summary>Path of the file being written to.</summary>
    [JsonPropertyName("fileName")]
    public required string FileName { get; set; }

    /// <summary>Human-readable description of the intended file change.</summary>
    [JsonPropertyName("intention")]
    public required string Intention { get; set; }

    /// <inheritdoc />
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("managedApprovalRequired")]
    public override bool? ManagedApprovalRequired
    {
        get => base.ManagedApprovalRequired;
        set => base.ManagedApprovalRequired = value;
    }

    /// <summary>Complete new file contents for newly created files.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("newFileContents")]
    public string? NewFileContents { get; set; }

    /// <summary>True when a built-in file tool (apply_patch / str_replace_editor) asked to write a path the sandbox filesystem policy would block, and the host opted in via sandbox.allowBypass. This is a request, not a grant: the write happens unsandboxed only if the user approves this permission request. Hosts should highlight the elevated risk in the approval UI.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("requestSandboxBypass")]
    public bool? RequestSandboxBypass { get; set; }

    /// <summary>Justification for the sandbox-bypass request. Only meaningful when requestSandboxBypass is true.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("requestSandboxBypassReason")]
    public string? RequestSandboxBypassReason { get; set; }

    /// <summary>Tool call ID that triggered this permission request.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("toolCallId")]
    public string? ToolCallId { get; set; }
}

/// <summary>File or directory read permission request.</summary>
/// <remarks>The <c>read</c> variant of <see cref="PermissionRequest"/>.</remarks>
public sealed partial class PermissionRequestRead : PermissionRequest
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "read";

    /// <summary>Human-readable description of why the file is being read.</summary>
    [JsonPropertyName("intention")]
    public required string Intention { get; set; }

    /// <inheritdoc />
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("managedApprovalRequired")]
    public override bool? ManagedApprovalRequired
    {
        get => base.ManagedApprovalRequired;
        set => base.ManagedApprovalRequired = value;
    }

    /// <summary>Path of the file or directory being read.</summary>
    [JsonPropertyName("path")]
    public required string Path { get; set; }

    /// <summary>True when the tool is asking to re-run this search outside the sandbox, after a sandboxed run looked blocked (host opted in via sandbox.allowBypass). The model cannot ask for this; only the tool raises it. This is a request, not a grant: the search runs unsandboxed only if the user approves this permission request. Hosts should highlight the elevated risk in the approval UI.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("requestSandboxBypass")]
    public bool? RequestSandboxBypass { get; set; }

    /// <summary>What the tool tells the user about the bypass on offer: which policy rule blocked the call, or why it cannot be sandboxed. Only meaningful when requestSandboxBypass is true.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("requestSandboxBypassReason")]
    public string? RequestSandboxBypassReason { get; set; }

    /// <summary>Tool call ID that triggered this permission request.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("toolCallId")]
    public string? ToolCallId { get; set; }
}

/// <summary>MCP tool invocation permission request.</summary>
/// <remarks>The <c>mcp</c> variant of <see cref="PermissionRequest"/>.</remarks>
public sealed partial class PermissionRequestMcp : PermissionRequest
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "mcp";

    /// <summary>Arguments to pass to the MCP tool.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("args")]
    public JsonElement? Args { get; set; }

    /// <summary>Advisory runtime permission recommendation. The SDK host remains responsible for deciding the request and may reject it.</summary>
    [Experimental(Diagnostics.Experimental)]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("permissionRecommendation")]
    public PermissionRecommendation? PermissionRecommendation { get; set; }

    /// <summary>Whether this MCP tool is read-only (no side effects).</summary>
    [JsonPropertyName("readOnly")]
    public required bool ReadOnly { get; set; }

    /// <summary>Name of the MCP server providing the tool.</summary>
    [JsonPropertyName("serverName")]
    public required string ServerName { get; set; }

    /// <summary>Tool call ID that triggered this permission request.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("toolCallId")]
    public string? ToolCallId { get; set; }

    /// <summary>Internal name of the MCP tool.</summary>
    [JsonPropertyName("toolName")]
    public required string ToolName { get; set; }

    /// <summary>Human-readable title of the MCP tool.</summary>
    [JsonPropertyName("toolTitle")]
    public required string ToolTitle { get; set; }
}

/// <summary>URL access permission request.</summary>
/// <remarks>The <c>url</c> variant of <see cref="PermissionRequest"/>.</remarks>
public sealed partial class PermissionRequestUrl : PermissionRequest
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "url";

    /// <summary>Human-readable description of why the URL is being accessed.</summary>
    [JsonPropertyName("intention")]
    public required string Intention { get; set; }

    /// <inheritdoc />
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("managedApprovalRequired")]
    public override bool? ManagedApprovalRequired
    {
        get => base.ManagedApprovalRequired;
        set => base.ManagedApprovalRequired = value;
    }

    /// <summary>Immediately preceding URL when this request is for a redirect target.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("redirectedFrom")]
    public string? RedirectedFrom { get; set; }

    /// <summary>True when the tool is asking to run this URL fetch outside the sandbox, after the network policy denied the approved URL or the sandbox proxy could not reach it (host opted in via sandbox.allowBypass). The model cannot ask for this; only the tool raises it. This is a request, not a grant: the fetch runs only if the user approves this permission request. Hosts should highlight the elevated risk in the approval UI.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("requestSandboxBypass")]
    public bool? RequestSandboxBypass { get; set; }

    /// <summary>What the tool tells the user about the bypass on offer: which policy rule blocked the call, or why it cannot be sandboxed. Only meaningful when requestSandboxBypass is true.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("requestSandboxBypassReason")]
    public string? RequestSandboxBypassReason { get; set; }

    /// <summary>Tool call ID that triggered this permission request.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("toolCallId")]
    public string? ToolCallId { get; set; }

    /// <summary>URL to be fetched.</summary>
    [JsonPropertyName("url")]
    public required string Url { get; set; }
}

/// <summary>Assisted-approval judge information attached to a permission request. Present only in assisted mode; its absence means the judge did not evaluate the request. The `recommendation` conveys the judge's disposition for this request.</summary>
/// <remarks>Nested data type for <c>PermissionAssistedApproval</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
public sealed partial class PermissionAssistedApproval
{
    /// <summary>Classified cause of an `error` recommendation. Absent for every other recommendation.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("failureReason")]
    public AssistedApprovalJudgeFailureReason? FailureReason { get; set; }

    /// <summary>Model id that produced the recommendation, when the judge was consulted and reported one. Absent for `excluded` (the judge was not consulted) and for failures that occurred before a model was selected.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("model")]
    public string? Model { get; set; }

    /// <summary>Human-readable reason for the judge's recommendation, when available.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("reason")]
    public string? Reason { get; set; }

    /// <summary>The assisted-approval safety judge's outcome for this request.</summary>
    [JsonPropertyName("recommendation")]
    public required AssistedApprovalRecommendation Recommendation { get; set; }
}

/// <summary>Memory operation permission request.</summary>
/// <remarks>The <c>memory</c> variant of <see cref="PermissionRequest"/>.</remarks>
public sealed partial class PermissionRequestMemory : PermissionRequest
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "memory";

    /// <summary>Whether this is a store or vote memory operation.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("action")]
    public PermissionRequestMemoryAction? Action { get; set; }

    /// <summary>Assisted-approval judge information for this request; present only in assisted mode.</summary>
    [Experimental(Diagnostics.Experimental)]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("assistedApproval")]
    public PermissionAssistedApproval? AssistedApproval { get; set; }

    /// <summary>Source references for the stored fact (store only).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("citations")]
    public string? Citations { get; set; }

    /// <summary>Vote direction (vote only).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("direction")]
    public PermissionRequestMemoryDirection? Direction { get; set; }

    /// <summary>The fact being stored or voted on.</summary>
    [JsonPropertyName("fact")]
    public required string Fact { get; set; }

    /// <summary>Reason for the vote (vote only).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("reason")]
    public string? Reason { get; set; }

    /// <summary>Repository name with owner associated with the stored memory (store only).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("repoNwo")]
    public string? RepoNwo { get; set; }

    /// <summary>Scope of the stored memory (store only).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("scope")]
    public PermissionRequestMemoryScope? Scope { get; set; }

    /// <summary>Topic or subject of the memory (store only).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("subject")]
    public string? Subject { get; set; }

    /// <summary>Tool call ID that triggered this permission request.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("toolCallId")]
    public string? ToolCallId { get; set; }
}

/// <summary>Custom tool invocation permission request.</summary>
/// <remarks>The <c>custom-tool</c> variant of <see cref="PermissionRequest"/>.</remarks>
public sealed partial class PermissionRequestCustomTool : PermissionRequest
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "custom-tool";

    /// <summary>Arguments to pass to the custom tool.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("args")]
    public JsonElement? Args { get; set; }

    /// <summary>Whether the tool declared that permission may be skipped unless a deny rule matches.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("skipPermission")]
    public bool? SkipPermission { get; set; }

    /// <summary>Tool call ID that triggered this permission request.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("toolCallId")]
    public string? ToolCallId { get; set; }

    /// <summary>Description of what the custom tool does.</summary>
    [JsonPropertyName("toolDescription")]
    public required string ToolDescription { get; set; }

    /// <summary>Name of the custom tool.</summary>
    [JsonPropertyName("toolName")]
    public required string ToolName { get; set; }
}

/// <summary>Hook confirmation permission request.</summary>
/// <remarks>The <c>hook</c> variant of <see cref="PermissionRequest"/>.</remarks>
public sealed partial class PermissionRequestHook : PermissionRequest
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "hook";

    /// <summary>Optional message from the hook explaining why confirmation is needed.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("hookMessage")]
    public string? HookMessage { get; set; }

    /// <summary>Arguments of the tool call being gated.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("toolArgs")]
    public JsonElement? ToolArgs { get; set; }

    /// <summary>Tool call ID that triggered this permission request.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("toolCallId")]
    public string? ToolCallId { get; set; }

    /// <summary>Name of the tool the hook is gating.</summary>
    [JsonPropertyName("toolName")]
    public required string ToolName { get; set; }
}

/// <summary>Extension management permission request.</summary>
/// <remarks>The <c>extension-management</c> variant of <see cref="PermissionRequest"/>.</remarks>
public sealed partial class PermissionRequestExtensionManagement : PermissionRequest
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "extension-management";

    /// <summary>Name of the extension being managed.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("extensionName")]
    public string? ExtensionName { get; set; }

    /// <summary>The extension management operation (scaffold, reload).</summary>
    [JsonPropertyName("operation")]
    public required string Operation { get; set; }

    /// <summary>Tool call ID that triggered this permission request.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("toolCallId")]
    public string? ToolCallId { get; set; }
}

/// <summary>A declared phase shown in a factory permission prompt.</summary>
/// <remarks>Nested data type for <c>FactoryPermissionPhase</c>.</remarks>
public sealed partial class FactoryPermissionPhase
{
    /// <summary>Optional phase detail.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("detail")]
    public string? Detail { get; set; }

    /// <summary>Phase title.</summary>
    [JsonPropertyName("title")]
    public required string Title { get; set; }
}

/// <summary>Factory run or authoring permission request.</summary>
/// <remarks>The <c>factory</c> variant of <see cref="PermissionRequest"/>.</remarks>
public sealed partial class PermissionRequestFactory : PermissionRequest
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "factory";

    /// <summary>Canonical key used for scoped factory approvals.</summary>
    [JsonPropertyName("approvalKey")]
    public required string ApprovalKey { get; set; }

    /// <summary>Whether this factory is eligible for persistent approval.</summary>
    [JsonPropertyName("canPersistApproval")]
    public required bool CanPersistApproval { get; set; }

    /// <summary>Factory-declared AI-credit limit before any run/resume caller override is applied.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("declaredMaxAiCredits")]
    public double? DeclaredMaxAiCredits { get; set; }

    /// <summary>Factory-declared concurrent-subagent limit before any run/resume caller override is applied.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("declaredMaxConcurrentSubagents")]
    public long? DeclaredMaxConcurrentSubagents { get; set; }

    /// <summary>Factory-declared total-subagent limit before any run/resume caller override is applied.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("declaredMaxTotalSubagents")]
    public long? DeclaredMaxTotalSubagents { get; set; }

    /// <summary>Factory-declared active-time limit in seconds before any run/resume caller override is applied.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("declaredTimeoutSeconds")]
    public double? DeclaredTimeoutSeconds { get; set; }

    /// <summary>Factory description.</summary>
    [JsonPropertyName("description")]
    public required string Description { get; set; }

    /// <summary>Effective AI-credit limit; omitted means unlimited.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("maxAiCredits")]
    public double? MaxAiCredits { get; set; }

    /// <summary>Effective concurrent-subagent limit; omitted means unlimited.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("maxConcurrentSubagents")]
    public long? MaxConcurrentSubagents { get; set; }

    /// <summary>Effective total-subagent limit; omitted means unlimited.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("maxTotalSubagents")]
    public long? MaxTotalSubagents { get; set; }

    /// <summary>Factory name.</summary>
    [JsonPropertyName("name")]
    public required string Name { get; set; }

    /// <summary>Factory operation, either run or author.</summary>
    [JsonPropertyName("operation")]
    public required FactoryPermissionOperation Operation { get; set; }

    /// <summary>Declared factory phases.</summary>
    [JsonPropertyName("phases")]
    public required FactoryPermissionPhase[] Phases { get; set; }

    /// <summary>Effective active-time limit in seconds; omitted means unlimited.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("timeoutSeconds")]
    public double? TimeoutSeconds { get; set; }

    /// <summary>Tool call ID that triggered this permission request.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("toolCallId")]
    public string? ToolCallId { get; set; }
}

/// <summary>Extension permission access request.</summary>
/// <remarks>The <c>extension-permission-access</c> variant of <see cref="PermissionRequest"/>.</remarks>
public sealed partial class PermissionRequestExtensionPermissionAccess : PermissionRequest
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "extension-permission-access";

    /// <summary>Capabilities the extension is requesting.</summary>
    [JsonPropertyName("capabilities")]
    public required string[] Capabilities { get; set; }

    /// <summary>Name of the extension requesting permission access.</summary>
    [JsonPropertyName("extensionName")]
    public required string ExtensionName { get; set; }

    /// <summary>Tool call ID that triggered this permission request.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("toolCallId")]
    public string? ToolCallId { get; set; }
}

/// <summary>Extension sensitive environment variable access request.</summary>
/// <remarks>The <c>extension-env-access</c> variant of <see cref="PermissionRequest"/>.</remarks>
public sealed partial class PermissionRequestExtensionEnvAccess : PermissionRequest
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "extension-env-access";

    /// <summary>Names of the sensitive environment variables the extension is requesting. Values never appear here.</summary>
    [JsonPropertyName("environmentVariables")]
    public required string[] EnvironmentVariables { get; set; }

    /// <summary>Name of the extension requesting environment variable access.</summary>
    [JsonPropertyName("extensionName")]
    public required string ExtensionName { get; set; }

    /// <summary>Tool call ID that triggered this permission request.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("toolCallId")]
    public string? ToolCallId { get; set; }
}

/// <summary>Details of the permission being requested.</summary>
/// <remarks>Polymorphic base type discriminated by <c>kind</c>.</remarks>
[JsonPolymorphic(
    TypeDiscriminatorPropertyName = "kind",
    UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FallBackToBaseType)]
[JsonDerivedType(typeof(PermissionRequestShell), "shell")]
[JsonDerivedType(typeof(PermissionRequestWrite), "write")]
[JsonDerivedType(typeof(PermissionRequestRead), "read")]
[JsonDerivedType(typeof(PermissionRequestMcp), "mcp")]
[JsonDerivedType(typeof(PermissionRequestUrl), "url")]
[JsonDerivedType(typeof(PermissionRequestMemory), "memory")]
[JsonDerivedType(typeof(PermissionRequestCustomTool), "custom-tool")]
[JsonDerivedType(typeof(PermissionRequestHook), "hook")]
[JsonDerivedType(typeof(PermissionRequestExtensionManagement), "extension-management")]
[JsonDerivedType(typeof(PermissionRequestFactory), "factory")]
[JsonDerivedType(typeof(PermissionRequestExtensionPermissionAccess), "extension-permission-access")]
[JsonDerivedType(typeof(PermissionRequestExtensionEnvAccess), "extension-env-access")]
public partial class PermissionRequest
{
    /// <summary>The type discriminator.</summary>
    [JsonPropertyName("kind")]
    public virtual string Kind { get; set; } = string.Empty;

    /// <summary>Whether managed policy requires a human response and forbids host auto-approval.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("managedApprovalRequired")]
    public virtual bool? ManagedApprovalRequired { get; set; }
}


/// <summary>Shell command permission prompt.</summary>
/// <remarks>The <c>commands</c> variant of <see cref="PermissionPromptRequest"/>.</remarks>
public sealed partial class PermissionPromptRequestCommands : PermissionPromptRequest
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "commands";

    /// <summary>Assisted-approval judge information for this request; present only in assisted mode.</summary>
    [Experimental(Diagnostics.Experimental)]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("assistedApproval")]
    public PermissionAssistedApproval? AssistedApproval { get; set; }

    /// <summary>Whether the UI can offer session-wide approval for this command pattern.</summary>
    [JsonPropertyName("canOfferSessionApproval")]
    public required bool CanOfferSessionApproval { get; set; }

    /// <summary>Command identifiers covered by this approval prompt.</summary>
    [JsonPropertyName("commandIdentifiers")]
    public required string[] CommandIdentifiers { get; set; }

    /// <summary>The complete shell command text to be executed.</summary>
    [JsonPropertyName("fullCommandText")]
    public required string FullCommandText { get; set; }

    /// <summary>Human-readable description of what the command intends to do.</summary>
    [JsonPropertyName("intention")]
    public required string Intention { get; set; }

    /// <summary>Whether managed policy requires a human response and forbids host auto-approval.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("managedApprovalRequired")]
    public bool? ManagedApprovalRequired { get; set; }

    /// <summary>Tool call ID that triggered this permission request.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("toolCallId")]
    public string? ToolCallId { get; set; }

    /// <summary>Optional warning message about risks of running this command.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("warning")]
    public string? Warning { get; set; }
}

/// <summary>File write permission prompt.</summary>
/// <remarks>The <c>write</c> variant of <see cref="PermissionPromptRequest"/>.</remarks>
public sealed partial class PermissionPromptRequestWrite : PermissionPromptRequest
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "write";

    /// <summary>Assisted-approval judge information for this request; present only in assisted mode.</summary>
    [Experimental(Diagnostics.Experimental)]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("assistedApproval")]
    public PermissionAssistedApproval? AssistedApproval { get; set; }

    /// <summary>Whether the UI can offer session-wide approval for file write operations.</summary>
    [JsonPropertyName("canOfferSessionApproval")]
    public required bool CanOfferSessionApproval { get; set; }

    /// <summary>Unified diff showing the proposed changes.</summary>
    [JsonPropertyName("diff")]
    public required string Diff { get; set; }

    /// <summary>Path of the file being written to.</summary>
    [JsonPropertyName("fileName")]
    public required string FileName { get; set; }

    /// <summary>Human-readable description of the intended file change.</summary>
    [JsonPropertyName("intention")]
    public required string Intention { get; set; }

    /// <summary>Whether managed policy requires a human response and forbids host auto-approval.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("managedApprovalRequired")]
    public bool? ManagedApprovalRequired { get; set; }

    /// <summary>Complete new file contents for newly created files.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("newFileContents")]
    public string? NewFileContents { get; set; }

    /// <summary>Tool call ID that triggered this permission request.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("toolCallId")]
    public string? ToolCallId { get; set; }
}

/// <summary>File read permission prompt.</summary>
/// <remarks>The <c>read</c> variant of <see cref="PermissionPromptRequest"/>.</remarks>
public sealed partial class PermissionPromptRequestRead : PermissionPromptRequest
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "read";

    /// <summary>Assisted-approval judge information for this request; present only in assisted mode.</summary>
    [Experimental(Diagnostics.Experimental)]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("assistedApproval")]
    public PermissionAssistedApproval? AssistedApproval { get; set; }

    /// <summary>Human-readable description of why the file is being read.</summary>
    [JsonPropertyName("intention")]
    public required string Intention { get; set; }

    /// <summary>Whether managed policy requires a human response and forbids host auto-approval.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("managedApprovalRequired")]
    public bool? ManagedApprovalRequired { get; set; }

    /// <summary>Path of the file or directory being read.</summary>
    [JsonPropertyName("path")]
    public required string Path { get; set; }

    /// <summary>Tool call ID that triggered this permission request.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("toolCallId")]
    public string? ToolCallId { get; set; }
}

/// <summary>MCP tool invocation permission prompt.</summary>
/// <remarks>The <c>mcp</c> variant of <see cref="PermissionPromptRequest"/>.</remarks>
public sealed partial class PermissionPromptRequestMcp : PermissionPromptRequest
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "mcp";

    /// <summary>Arguments to pass to the MCP tool.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("args")]
    public JsonElement? Args { get; set; }

    /// <summary>Assisted-approval judge information for this request; present only in assisted mode.</summary>
    [Experimental(Diagnostics.Experimental)]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("assistedApproval")]
    public PermissionAssistedApproval? AssistedApproval { get; set; }

    /// <summary>Whether the host may offer a server-wide "approve all tools from this server" blanket. Absent is treated as true; the runtime sends false when managed policy disables bypass-permissions mode, which forbids the server-wide escalation while still allowing per-tool approval.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("canOfferServerWideApproval")]
    public bool? CanOfferServerWideApproval { get; set; }

    /// <summary>Advisory runtime permission recommendation. The host remains responsible for deciding the request and may reject it.</summary>
    [Experimental(Diagnostics.Experimental)]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("permissionRecommendation")]
    public PermissionRecommendation? PermissionRecommendation { get; set; }

    /// <summary>Name of the MCP server providing the tool.</summary>
    [JsonPropertyName("serverName")]
    public required string ServerName { get; set; }

    /// <summary>Tool call ID that triggered this permission request.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("toolCallId")]
    public string? ToolCallId { get; set; }

    /// <summary>Internal name of the MCP tool.</summary>
    [JsonPropertyName("toolName")]
    public required string ToolName { get; set; }

    /// <summary>Human-readable title of the MCP tool.</summary>
    [JsonPropertyName("toolTitle")]
    public required string ToolTitle { get; set; }
}

/// <summary>URL access permission prompt.</summary>
/// <remarks>The <c>url</c> variant of <see cref="PermissionPromptRequest"/>.</remarks>
public sealed partial class PermissionPromptRequestUrl : PermissionPromptRequest
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "url";

    /// <summary>Assisted-approval judge information for this request; present only in assisted mode.</summary>
    [Experimental(Diagnostics.Experimental)]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("assistedApproval")]
    public PermissionAssistedApproval? AssistedApproval { get; set; }

    /// <summary>Human-readable description of why the URL is being accessed.</summary>
    [JsonPropertyName("intention")]
    public required string Intention { get; set; }

    /// <summary>Whether managed policy requires a human response and forbids host auto-approval.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("managedApprovalRequired")]
    public bool? ManagedApprovalRequired { get; set; }

    /// <summary>Immediately preceding URL when this prompt is for a redirect target.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("redirectedFrom")]
    public string? RedirectedFrom { get; set; }

    /// <summary>True when the tool is asking to run this URL fetch outside the sandbox, after the network policy denied the approved URL or the sandbox proxy could not reach it (host opted in via sandbox.allowBypass). The model cannot ask for this; only the tool raises it. This is a request, not a grant: the fetch runs only if the user approves this permission request. Hosts should highlight the elevated risk in the approval UI.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("requestSandboxBypass")]
    public bool? RequestSandboxBypass { get; set; }

    /// <summary>What the tool tells the user about the bypass on offer: which policy rule blocked the call, or why it cannot be sandboxed. Only meaningful when requestSandboxBypass is true.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("requestSandboxBypassReason")]
    public string? RequestSandboxBypassReason { get; set; }

    /// <summary>Tool call ID that triggered this permission request.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("toolCallId")]
    public string? ToolCallId { get; set; }

    /// <summary>URL to be fetched.</summary>
    [JsonPropertyName("url")]
    public required string Url { get; set; }
}

/// <summary>Memory operation permission prompt.</summary>
/// <remarks>The <c>memory</c> variant of <see cref="PermissionPromptRequest"/>.</remarks>
public sealed partial class PermissionPromptRequestMemory : PermissionPromptRequest
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "memory";

    /// <summary>Whether this is a store or vote memory operation.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("action")]
    public PermissionRequestMemoryAction? Action { get; set; }

    /// <summary>Assisted-approval judge information for this request; present only in assisted mode.</summary>
    [Experimental(Diagnostics.Experimental)]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("assistedApproval")]
    public PermissionAssistedApproval? AssistedApproval { get; set; }

    /// <summary>Source references for the stored fact (store only).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("citations")]
    public string? Citations { get; set; }

    /// <summary>Vote direction (vote only).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("direction")]
    public PermissionRequestMemoryDirection? Direction { get; set; }

    /// <summary>The fact being stored or voted on.</summary>
    [JsonPropertyName("fact")]
    public required string Fact { get; set; }

    /// <summary>Reason for the vote (vote only).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("reason")]
    public string? Reason { get; set; }

    /// <summary>Topic or subject of the memory (store only).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("subject")]
    public string? Subject { get; set; }

    /// <summary>Tool call ID that triggered this permission request.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("toolCallId")]
    public string? ToolCallId { get; set; }
}

/// <summary>Custom tool invocation permission prompt.</summary>
/// <remarks>The <c>custom-tool</c> variant of <see cref="PermissionPromptRequest"/>.</remarks>
public sealed partial class PermissionPromptRequestCustomTool : PermissionPromptRequest
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "custom-tool";

    /// <summary>Arguments to pass to the custom tool.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("args")]
    public JsonElement? Args { get; set; }

    /// <summary>Assisted-approval judge information for this request; present only in assisted mode.</summary>
    [Experimental(Diagnostics.Experimental)]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("assistedApproval")]
    public PermissionAssistedApproval? AssistedApproval { get; set; }

    /// <summary>Tool call ID that triggered this permission request.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("toolCallId")]
    public string? ToolCallId { get; set; }

    /// <summary>Description of what the custom tool does.</summary>
    [JsonPropertyName("toolDescription")]
    public required string ToolDescription { get; set; }

    /// <summary>Name of the custom tool.</summary>
    [JsonPropertyName("toolName")]
    public required string ToolName { get; set; }
}

/// <summary>Path access permission prompt.</summary>
/// <remarks>The <c>path</c> variant of <see cref="PermissionPromptRequest"/>.</remarks>
public sealed partial class PermissionPromptRequestPath : PermissionPromptRequest
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "path";

    /// <summary>Underlying permission kind that needs path approval.</summary>
    [JsonPropertyName("accessKind")]
    public required PermissionPromptRequestPathAccessKind AccessKind { get; set; }

    /// <summary>Assisted-approval judge information for this request; present only in assisted mode.</summary>
    [Experimental(Diagnostics.Experimental)]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("assistedApproval")]
    public PermissionAssistedApproval? AssistedApproval { get; set; }

    /// <summary>File paths that require explicit approval.</summary>
    [JsonPropertyName("paths")]
    public required string[] Paths { get; set; }

    /// <summary>Tool call ID that triggered this permission request.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("toolCallId")]
    public string? ToolCallId { get; set; }
}

/// <summary>Hook confirmation permission prompt.</summary>
/// <remarks>The <c>hook</c> variant of <see cref="PermissionPromptRequest"/>.</remarks>
public sealed partial class PermissionPromptRequestHook : PermissionPromptRequest
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "hook";

    /// <summary>Assisted-approval judge information for this request; present only in assisted mode.</summary>
    [Experimental(Diagnostics.Experimental)]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("assistedApproval")]
    public PermissionAssistedApproval? AssistedApproval { get; set; }

    /// <summary>Optional message from the hook explaining why confirmation is needed.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("hookMessage")]
    public string? HookMessage { get; set; }

    /// <summary>Arguments of the tool call being gated.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("toolArgs")]
    public JsonElement? ToolArgs { get; set; }

    /// <summary>Tool call ID that triggered this permission request.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("toolCallId")]
    public string? ToolCallId { get; set; }

    /// <summary>Name of the tool the hook is gating.</summary>
    [JsonPropertyName("toolName")]
    public required string ToolName { get; set; }
}

/// <summary>Extension management permission prompt.</summary>
/// <remarks>The <c>extension-management</c> variant of <see cref="PermissionPromptRequest"/>.</remarks>
public sealed partial class PermissionPromptRequestExtensionManagement : PermissionPromptRequest
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "extension-management";

    /// <summary>Assisted-approval judge information for this request; present only in assisted mode.</summary>
    [Experimental(Diagnostics.Experimental)]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("assistedApproval")]
    public PermissionAssistedApproval? AssistedApproval { get; set; }

    /// <summary>Name of the extension being managed.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("extensionName")]
    public string? ExtensionName { get; set; }

    /// <summary>The extension management operation (scaffold, reload).</summary>
    [JsonPropertyName("operation")]
    public required string Operation { get; set; }

    /// <summary>Tool call ID that triggered this permission request.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("toolCallId")]
    public string? ToolCallId { get; set; }
}

/// <summary>Factory run or authoring permission prompt.</summary>
/// <remarks>The <c>factory</c> variant of <see cref="PermissionPromptRequest"/>.</remarks>
public sealed partial class PermissionPromptRequestFactory : PermissionPromptRequest
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "factory";

    /// <summary>Canonical key used for scoped factory approvals.</summary>
    [JsonPropertyName("approvalKey")]
    public required string ApprovalKey { get; set; }

    /// <summary>Assisted-approval judge information for this request; present only in assisted mode.</summary>
    [Experimental(Diagnostics.Experimental)]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("assistedApproval")]
    public PermissionAssistedApproval? AssistedApproval { get; set; }

    /// <summary>Whether this factory is eligible for persistent approval.</summary>
    [JsonPropertyName("canPersistApproval")]
    public required bool CanPersistApproval { get; set; }

    /// <summary>Factory-declared AI-credit limit before any run/resume caller override is applied.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("declaredMaxAiCredits")]
    public double? DeclaredMaxAiCredits { get; set; }

    /// <summary>Factory-declared concurrent-subagent limit before any run/resume caller override is applied.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("declaredMaxConcurrentSubagents")]
    public long? DeclaredMaxConcurrentSubagents { get; set; }

    /// <summary>Factory-declared total-subagent limit before any run/resume caller override is applied.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("declaredMaxTotalSubagents")]
    public long? DeclaredMaxTotalSubagents { get; set; }

    /// <summary>Factory-declared active-time limit in seconds before any run/resume caller override is applied.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("declaredTimeoutSeconds")]
    public double? DeclaredTimeoutSeconds { get; set; }

    /// <summary>Factory description.</summary>
    [JsonPropertyName("description")]
    public required string Description { get; set; }

    /// <summary>Whether managed policy requires a human response and forbids host auto-approval.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("managedApprovalRequired")]
    public bool? ManagedApprovalRequired { get; set; }

    /// <summary>Effective AI-credit limit; omitted means unlimited.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("maxAiCredits")]
    public double? MaxAiCredits { get; set; }

    /// <summary>Effective concurrent-subagent limit; omitted means unlimited.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("maxConcurrentSubagents")]
    public long? MaxConcurrentSubagents { get; set; }

    /// <summary>Effective total-subagent limit; omitted means unlimited.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("maxTotalSubagents")]
    public long? MaxTotalSubagents { get; set; }

    /// <summary>Factory name.</summary>
    [JsonPropertyName("name")]
    public required string Name { get; set; }

    /// <summary>Factory operation, either run or author.</summary>
    [JsonPropertyName("operation")]
    public required FactoryPermissionOperation Operation { get; set; }

    /// <summary>Declared factory phases.</summary>
    [JsonPropertyName("phases")]
    public required FactoryPermissionPhase[] Phases { get; set; }

    /// <summary>Effective active-time limit in seconds; omitted means unlimited.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("timeoutSeconds")]
    public double? TimeoutSeconds { get; set; }

    /// <summary>Tool call ID that triggered this permission request.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("toolCallId")]
    public string? ToolCallId { get; set; }
}

/// <summary>Extension permission access prompt.</summary>
/// <remarks>The <c>extension-permission-access</c> variant of <see cref="PermissionPromptRequest"/>.</remarks>
public sealed partial class PermissionPromptRequestExtensionPermissionAccess : PermissionPromptRequest
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "extension-permission-access";

    /// <summary>Assisted-approval judge information for this request; present only in assisted mode.</summary>
    [Experimental(Diagnostics.Experimental)]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("assistedApproval")]
    public PermissionAssistedApproval? AssistedApproval { get; set; }

    /// <summary>Capabilities the extension is requesting.</summary>
    [JsonPropertyName("capabilities")]
    public required string[] Capabilities { get; set; }

    /// <summary>Name of the extension requesting permission access.</summary>
    [JsonPropertyName("extensionName")]
    public required string ExtensionName { get; set; }

    /// <summary>Tool call ID that triggered this permission request.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("toolCallId")]
    public string? ToolCallId { get; set; }
}

/// <summary>Extension sensitive environment variable access prompt.</summary>
/// <remarks>The <c>extension-env-access</c> variant of <see cref="PermissionPromptRequest"/>.</remarks>
public sealed partial class PermissionPromptRequestExtensionEnvAccess : PermissionPromptRequest
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "extension-env-access";

    /// <summary>Assisted-approval judge information for this request; present only in assisted mode.</summary>
    [Experimental(Diagnostics.Experimental)]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("assistedApproval")]
    public PermissionAssistedApproval? AssistedApproval { get; set; }

    /// <summary>Names of the sensitive environment variables the extension is requesting. Values never appear here.</summary>
    [JsonPropertyName("environmentVariables")]
    public required string[] EnvironmentVariables { get; set; }

    /// <summary>Name of the extension requesting environment variable access.</summary>
    [JsonPropertyName("extensionName")]
    public required string ExtensionName { get; set; }

    /// <summary>Tool call ID that triggered this permission request.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("toolCallId")]
    public string? ToolCallId { get; set; }
}

/// <summary>Derived user-facing permission prompt details for UI consumers.</summary>
/// <remarks>Polymorphic base type discriminated by <c>kind</c>.</remarks>
[JsonPolymorphic(
    TypeDiscriminatorPropertyName = "kind",
    UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FallBackToBaseType)]
[JsonDerivedType(typeof(PermissionPromptRequestCommands), "commands")]
[JsonDerivedType(typeof(PermissionPromptRequestWrite), "write")]
[JsonDerivedType(typeof(PermissionPromptRequestRead), "read")]
[JsonDerivedType(typeof(PermissionPromptRequestMcp), "mcp")]
[JsonDerivedType(typeof(PermissionPromptRequestUrl), "url")]
[JsonDerivedType(typeof(PermissionPromptRequestMemory), "memory")]
[JsonDerivedType(typeof(PermissionPromptRequestCustomTool), "custom-tool")]
[JsonDerivedType(typeof(PermissionPromptRequestPath), "path")]
[JsonDerivedType(typeof(PermissionPromptRequestHook), "hook")]
[JsonDerivedType(typeof(PermissionPromptRequestExtensionManagement), "extension-management")]
[JsonDerivedType(typeof(PermissionPromptRequestFactory), "factory")]
[JsonDerivedType(typeof(PermissionPromptRequestExtensionPermissionAccess), "extension-permission-access")]
[JsonDerivedType(typeof(PermissionPromptRequestExtensionEnvAccess), "extension-env-access")]
public partial class PermissionPromptRequest
{
    /// <summary>The type discriminator.</summary>
    [JsonPropertyName("kind")]
    public virtual string Kind { get; set; } = string.Empty;
}


/// <summary>Permission response variant indicating the request was approved without persisting an approval rule.</summary>
/// <remarks>The <c>approved</c> variant of <see cref="PermissionResult"/>.</remarks>
public sealed partial class PermissionResultApproved : PermissionResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "approved";

    /// <summary>Whether a managed approval policy already handled this request.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("managedApprovalHandled")]
    public bool? ManagedApprovalHandled { get; set; }
}

/// <summary>Session-scoped tool-approval rule for specific shell command identifiers.</summary>
/// <remarks>The <c>commands</c> variant of <see cref="UserToolSessionApproval"/>.</remarks>
public sealed partial class UserToolSessionApprovalCommands : UserToolSessionApproval
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "commands";

    /// <summary>Command identifiers approved by the user.</summary>
    [JsonPropertyName("commandIdentifiers")]
    public required string[] CommandIdentifiers { get; set; }
}

/// <summary>Session-scoped tool-approval rule for read-only filesystem operations.</summary>
/// <remarks>The <c>read</c> variant of <see cref="UserToolSessionApproval"/>.</remarks>
public sealed partial class UserToolSessionApprovalRead : UserToolSessionApproval
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "read";
}

/// <summary>Session-scoped tool-approval rule for filesystem write operations.</summary>
/// <remarks>The <c>write</c> variant of <see cref="UserToolSessionApproval"/>.</remarks>
public sealed partial class UserToolSessionApprovalWrite : UserToolSessionApproval
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "write";
}

/// <summary>Session-scoped tool-approval rule for an MCP server tool, or all tools on the server when `toolName` is null.</summary>
/// <remarks>The <c>mcp</c> variant of <see cref="UserToolSessionApproval"/>.</remarks>
public sealed partial class UserToolSessionApprovalMcp : UserToolSessionApproval
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "mcp";

    /// <summary>MCP server name.</summary>
    [JsonPropertyName("serverName")]
    public required string ServerName { get; set; }

    /// <summary>Optional MCP tool name, or null for all tools on the server.</summary>
    [JsonPropertyName("toolName")]
    public string? ToolName { get; set; }
}

/// <summary>Session-scoped tool-approval rule for writes to long-term memory.</summary>
/// <remarks>The <c>memory</c> variant of <see cref="UserToolSessionApproval"/>.</remarks>
public sealed partial class UserToolSessionApprovalMemory : UserToolSessionApproval
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "memory";
}

/// <summary>Session-scoped tool-approval rule for a custom tool, keyed by tool name.</summary>
/// <remarks>The <c>custom-tool</c> variant of <see cref="UserToolSessionApproval"/>.</remarks>
public sealed partial class UserToolSessionApprovalCustomTool : UserToolSessionApproval
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "custom-tool";

    /// <summary>Custom tool name.</summary>
    [JsonPropertyName("toolName")]
    public required string ToolName { get; set; }
}

/// <summary>Session-scoped tool-approval rule for extension-management operations, optionally narrowed by operation.</summary>
/// <remarks>The <c>extension-management</c> variant of <see cref="UserToolSessionApproval"/>.</remarks>
public sealed partial class UserToolSessionApprovalExtensionManagement : UserToolSessionApproval
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "extension-management";

    /// <summary>Optional operation identifier.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("operation")]
    public string? Operation { get; set; }
}

/// <summary>Session-scoped factory approval, optionally narrowed by approval key.</summary>
/// <remarks>The <c>factory</c> variant of <see cref="UserToolSessionApproval"/>.</remarks>
public sealed partial class UserToolSessionApprovalFactory : UserToolSessionApproval
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "factory";

    /// <summary>Optional factory operation name or canonical approval key.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("approvalKey")]
    public string? ApprovalKey { get; set; }
}

/// <summary>Session-scoped tool-approval rule for an extension's permission-gated capability access, keyed by extension name.</summary>
/// <remarks>The <c>extension-permission-access</c> variant of <see cref="UserToolSessionApproval"/>.</remarks>
public sealed partial class UserToolSessionApprovalExtensionPermissionAccess : UserToolSessionApproval
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "extension-permission-access";

    /// <summary>Extension name.</summary>
    [JsonPropertyName("extensionName")]
    public required string ExtensionName { get; set; }
}

/// <summary>Session-scoped tool-approval rule for an extension's access to sensitive environment variables, keyed by extension name and the exact set of variable names.</summary>
/// <remarks>The <c>extension-env-access</c> variant of <see cref="UserToolSessionApproval"/>.</remarks>
public sealed partial class UserToolSessionApprovalExtensionEnvAccess : UserToolSessionApproval
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "extension-env-access";

    /// <summary>Names of the sensitive environment variables this approval covers. Values are never persisted.</summary>
    [JsonPropertyName("environmentVariables")]
    public required string[] EnvironmentVariables { get; set; }

    /// <summary>Extension name.</summary>
    [JsonPropertyName("extensionName")]
    public required string ExtensionName { get; set; }
}

/// <summary>The approval to add as a session-scoped rule.</summary>
/// <remarks>Polymorphic base type discriminated by <c>kind</c>.</remarks>
[JsonPolymorphic(
    TypeDiscriminatorPropertyName = "kind",
    UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FallBackToBaseType)]
[JsonDerivedType(typeof(UserToolSessionApprovalCommands), "commands")]
[JsonDerivedType(typeof(UserToolSessionApprovalRead), "read")]
[JsonDerivedType(typeof(UserToolSessionApprovalWrite), "write")]
[JsonDerivedType(typeof(UserToolSessionApprovalMcp), "mcp")]
[JsonDerivedType(typeof(UserToolSessionApprovalMemory), "memory")]
[JsonDerivedType(typeof(UserToolSessionApprovalCustomTool), "custom-tool")]
[JsonDerivedType(typeof(UserToolSessionApprovalExtensionManagement), "extension-management")]
[JsonDerivedType(typeof(UserToolSessionApprovalFactory), "factory")]
[JsonDerivedType(typeof(UserToolSessionApprovalExtensionPermissionAccess), "extension-permission-access")]
[JsonDerivedType(typeof(UserToolSessionApprovalExtensionEnvAccess), "extension-env-access")]
public partial class UserToolSessionApproval
{
    /// <summary>The type discriminator.</summary>
    [JsonPropertyName("kind")]
    public virtual string Kind { get; set; } = string.Empty;
}


/// <summary>Permission response variant that approves a request and remembers the provided approval for the rest of the session.</summary>
/// <remarks>The <c>approved-for-session</c> variant of <see cref="PermissionResult"/>.</remarks>
public sealed partial class PermissionResultApprovedForSession : PermissionResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "approved-for-session";

    /// <summary>The approval to add as a session-scoped rule.</summary>
    [JsonPropertyName("approval")]
    public required UserToolSessionApproval Approval { get; set; }

    /// <summary>Whether a managed approval policy already handled this request.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("managedApprovalHandled")]
    public bool? ManagedApprovalHandled { get; set; }
}

/// <summary>Permission response variant that approves a request and persists the provided approval to a project location key.</summary>
/// <remarks>The <c>approved-for-location</c> variant of <see cref="PermissionResult"/>.</remarks>
public sealed partial class PermissionResultApprovedForLocation : PermissionResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "approved-for-location";

    /// <summary>The approval to persist for this location.</summary>
    [JsonPropertyName("approval")]
    public required UserToolSessionApproval Approval { get; set; }

    /// <summary>The location key (git root or cwd) to persist the approval to.</summary>
    [JsonPropertyName("locationKey")]
    public required string LocationKey { get; set; }

    /// <summary>Whether a managed approval policy already handled this request.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("managedApprovalHandled")]
    public bool? ManagedApprovalHandled { get; set; }
}

/// <summary>Permission response variant indicating the request was cancelled before use, with an optional reason.</summary>
/// <remarks>The <c>cancelled</c> variant of <see cref="PermissionResult"/>.</remarks>
public sealed partial class PermissionResultCancelled : PermissionResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "cancelled";

    /// <summary>Optional explanation of why the request was cancelled.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("reason")]
    public string? Reason { get; set; }
}

/// <summary>A permission approval or denial rule matched against a tool request, identified by a rule kind with an optional argument value.</summary>
/// <remarks>Nested data type for <c>PermissionRule</c>.</remarks>
public sealed partial class PermissionRule
{
    /// <summary>Argument value matched against the request, or null when the rule kind has no argument (e.g. 'read', 'write', 'memory').</summary>
    [JsonPropertyName("argument")]
    public string? Argument { get; set; }

    /// <summary>The rule kind, such as Shell or GitHubMCP.</summary>
    [JsonPropertyName("kind")]
    public required string Kind { get; set; }
}

/// <summary>Permission response variant denied because matching approval rules explicitly blocked the request.</summary>
/// <remarks>The <c>denied-by-rules</c> variant of <see cref="PermissionResult"/>.</remarks>
public sealed partial class PermissionResultDeniedByRules : PermissionResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "denied-by-rules";

    /// <summary>Rules that denied the request.</summary>
    [JsonPropertyName("rules")]
    public required PermissionRule[] Rules { get; set; }
}

/// <summary>Permission response variant denied because no approval rule matched and user confirmation was unavailable.</summary>
/// <remarks>The <c>denied-no-approval-rule-and-could-not-request-from-user</c> variant of <see cref="PermissionResult"/>.</remarks>
public sealed partial class PermissionResultDeniedNoApprovalRuleAndCouldNotRequestFromUser : PermissionResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "denied-no-approval-rule-and-could-not-request-from-user";
}

/// <summary>Permission response variant denied in an interactive user prompt, with optional feedback and force-reject flag.</summary>
/// <remarks>The <c>denied-interactively-by-user</c> variant of <see cref="PermissionResult"/>.</remarks>
public sealed partial class PermissionResultDeniedInteractivelyByUser : PermissionResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "denied-interactively-by-user";

    /// <summary>Optional feedback from the user explaining the denial.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("feedback")]
    public string? Feedback { get; set; }

    /// <summary>Whether to force-reject the current agent turn.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("forceReject")]
    public bool? ForceReject { get; set; }
}

/// <summary>Permission response variant denying a path under content exclusion policy, with the path and message.</summary>
/// <remarks>The <c>denied-by-content-exclusion-policy</c> variant of <see cref="PermissionResult"/>.</remarks>
public sealed partial class PermissionResultDeniedByContentExclusionPolicy : PermissionResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "denied-by-content-exclusion-policy";

    /// <summary>Human-readable explanation of why the path was excluded.</summary>
    [JsonPropertyName("message")]
    public required string Message { get; set; }

    /// <summary>File path that triggered the exclusion.</summary>
    [JsonPropertyName("path")]
    public required string Path { get; set; }
}

/// <summary>Permission response variant denied by a permission-request hook, with optional message and interrupt flag.</summary>
/// <remarks>The <c>denied-by-permission-request-hook</c> variant of <see cref="PermissionResult"/>.</remarks>
public sealed partial class PermissionResultDeniedByPermissionRequestHook : PermissionResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "denied-by-permission-request-hook";

    /// <summary>Whether to interrupt the current agent turn.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("interrupt")]
    public bool? Interrupt { get; set; }

    /// <summary>Optional message from the hook explaining the denial.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("message")]
    public string? Message { get; set; }
}

/// <summary>The result of the permission request.</summary>
/// <remarks>Polymorphic base type discriminated by <c>kind</c>.</remarks>
[JsonPolymorphic(
    TypeDiscriminatorPropertyName = "kind",
    UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FallBackToBaseType)]
[JsonDerivedType(typeof(PermissionResultApproved), "approved")]
[JsonDerivedType(typeof(PermissionResultApprovedForSession), "approved-for-session")]
[JsonDerivedType(typeof(PermissionResultApprovedForLocation), "approved-for-location")]
[JsonDerivedType(typeof(PermissionResultCancelled), "cancelled")]
[JsonDerivedType(typeof(PermissionResultDeniedByRules), "denied-by-rules")]
[JsonDerivedType(typeof(PermissionResultDeniedNoApprovalRuleAndCouldNotRequestFromUser), "denied-no-approval-rule-and-could-not-request-from-user")]
[JsonDerivedType(typeof(PermissionResultDeniedInteractivelyByUser), "denied-interactively-by-user")]
[JsonDerivedType(typeof(PermissionResultDeniedByContentExclusionPolicy), "denied-by-content-exclusion-policy")]
[JsonDerivedType(typeof(PermissionResultDeniedByPermissionRequestHook), "denied-by-permission-request-hook")]
public partial class PermissionResult
{
    /// <summary>The type discriminator.</summary>
    [JsonPropertyName("kind")]
    public virtual string Kind { get; set; } = string.Empty;
}


/// <summary>JSON Schema describing the form fields to present to the user (form mode only).</summary>
/// <remarks>Nested data type for <c>ElicitationRequestedSchema</c>.</remarks>
public sealed partial class ElicitationRequestedSchema
{
    /// <summary>Form field definitions, keyed by field name.</summary>
    [JsonPropertyName("properties")]
    public required IDictionary<string, JsonElement> Properties { get; set; }

    /// <summary>List of required field names.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("required")]
    public string[]? Required { get; set; }

    /// <summary>Schema type indicator (always 'object').</summary>
    [JsonPropertyName("type")]
    public required string Type { get; set; }
}

/// <summary>Single HTTP header entry as a name/value pair.</summary>
/// <remarks>Nested data type for <c>HeaderEntry</c>.</remarks>
public sealed partial class HeaderEntry
{
    /// <summary>HTTP response header name as observed by the runtime.</summary>
    [JsonPropertyName("name")]
    public required string Name { get; set; }

    /// <summary>HTTP response header value as observed by the runtime.</summary>
    [JsonPropertyName("value")]
    public required string Value { get; set; }
}

/// <summary>Raw HTTP response details from the OAuth auth challenge, as observed by the runtime.</summary>
/// <remarks>Nested data type for <c>McpOauthHttpResponse</c>.</remarks>
public sealed partial class McpOauthHttpResponse
{
    /// <summary>Complete UTF-8 response body for host-specific challenge handling, including an empty string for an empty body. Omitted when the complete body is not valid UTF-8; body read failures fail the HTTP operation rather than exposing a partial response.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("body")]
    public string? Body { get; set; }

    /// <summary>HTTP response headers as observed by the runtime. Order and casing are transport-dependent, and duplicate header names may appear multiple times.</summary>
    [JsonPropertyName("headers")]
    public required HeaderEntry[] Headers { get; set; }

    /// <summary>HTTP status code returned with the auth challenge.</summary>
    [JsonPropertyName("statusCode")]
    public required int StatusCode { get; set; }
}

/// <summary>Static OAuth client configuration, if the server specifies one.</summary>
/// <remarks>Nested data type for <c>McpOauthRequiredStaticClientConfig</c>.</remarks>
public sealed partial class McpOauthRequiredStaticClientConfig
{
    /// <summary>OAuth client ID for the server.</summary>
    [JsonPropertyName("clientId")]
    public required string ClientId { get; set; }

    /// <summary>Optional OAuth client secret for confidential static clients, when the runtime can resolve one.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("clientSecret")]
    public string? ClientSecret { get; set; }

    /// <summary>Optional non-default OAuth grant type. When set to 'client_credentials', the OAuth flow runs headlessly using the client_id + keychain-stored secret (no browser, no callback server).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("grantType")]
    public string? GrantType { get; set; }

    /// <summary>Whether this is a public OAuth client.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("publicClient")]
    public bool? PublicClient { get; set; }
}

/// <summary>OAuth WWW-Authenticate parameters parsed from an MCP auth challenge.</summary>
/// <remarks>Nested data type for <c>McpOauthWWWAuthenticateParams</c>.</remarks>
public sealed partial class McpOauthWWWAuthenticateParams
{
    /// <summary>OAuth error from the WWW-Authenticate error parameter, if present.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("error")]
    public string? Error { get; set; }

    /// <summary>Protected resource metadata URL from the WWW-Authenticate resource_metadata parameter, if present.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("resourceMetadataUrl")]
    public string? ResourceMetadataUrl { get; set; }

    /// <summary>Requested OAuth scopes from the WWW-Authenticate scope parameter, if present.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("scope")]
    public string? Scope { get; set; }
}

/// <summary>The user's selected action for an exhausted session limit.</summary>
/// <remarks>Nested data type for <c>SessionLimitsExhaustedResponse</c>.</remarks>
public sealed partial class SessionLimitsExhaustedResponse
{
    /// <summary>Action selected by the user.</summary>
    [JsonPropertyName("action")]
    public required SessionLimitsExhaustedResponseAction Action { get; set; }

    /// <summary>AI Credits to add to the current max when action is 'add'.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("additionalAiCredits")]
    public double? AdditionalAiCredits { get; set; }

    /// <summary>New absolute max AI Credits when action is 'set'.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("maxAiCredits")]
    public double? MaxAiCredits { get; set; }
}

/// <summary>A single slash command available in the session, as listed by the `commands.changed` event.</summary>
/// <remarks>Nested data type for <c>CommandsChangedCommand</c>.</remarks>
public sealed partial class CommandsChangedCommand
{
    /// <summary>Optional human-readable command description.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("description")]
    public string? Description { get; set; }

    /// <summary>Slash command name without the leading slash.</summary>
    [JsonPropertyName("name")]
    public required string Name { get; set; }
}

/// <summary>UI capability changes.</summary>
/// <remarks>Nested data type for <c>CapabilitiesChangedUI</c>.</remarks>
public sealed partial class CapabilitiesChangedUI
{
    /// <summary>Whether canvas rendering is now supported.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("canvases")]
    public bool? Canvases { get; set; }

    /// <summary>Whether elicitation is now supported.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("elicitation")]
    public bool? Elicitation { get; set; }

    /// <summary>Whether MCP Apps (SEP-1865) UI passthrough is now supported.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("mcpApps")]
    public bool? McpApps { get; set; }
}

/// <summary>A single resolved skill in `session.skills_loaded`, including source, invocability, enabled state, path, and argument hint.</summary>
/// <remarks>Nested data type for <c>SkillsLoadedSkill</c>.</remarks>
public sealed partial class SkillsLoadedSkill
{
    /// <summary>Optional freeform hint describing the skill's expected arguments, from the `argument-hint` frontmatter field.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("argumentHint")]
    public string? ArgumentHint { get; set; }

    /// <summary>Canonical slash command name used to invoke the skill, without the leading '/'.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("commandName")]
    public string? CommandName { get; set; }

    /// <summary>Description of what the skill does.</summary>
    [JsonPropertyName("description")]
    public required string Description { get; set; }

    /// <summary>Whether the skill is currently enabled.</summary>
    [JsonPropertyName("enabled")]
    public required bool Enabled { get; set; }

    /// <summary>Unique identifier for the skill.</summary>
    [JsonPropertyName("name")]
    public required string Name { get; set; }

    /// <summary>Absolute path to the skill file, if available.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("path")]
    public string? Path { get; set; }

    /// <summary>Source location type (e.g., project, personal-copilot, plugin, builtin, remote, sdk).</summary>
    [JsonPropertyName("source")]
    public required SkillSource Source { get; set; }

    /// <summary>Whether the skill can be invoked by the user as a slash command.</summary>
    [JsonPropertyName("userInvocable")]
    public required bool UserInvocable { get; set; }
}

/// <summary>A single loaded custom agent in `session.custom_agents_updated`, with identity, source, tools, invocability, and authored model configuration.</summary>
/// <remarks>Nested data type for <c>CustomAgentsUpdatedAgent</c>.</remarks>
public sealed partial class CustomAgentsUpdatedAgent
{
    /// <summary>Description of what the agent does.</summary>
    [JsonPropertyName("description")]
    public required string Description { get; set; }

    /// <summary>Human-readable display name.</summary>
    [JsonPropertyName("displayName")]
    public required string DisplayName { get; set; }

    /// <summary>Unique identifier for the agent.</summary>
    [JsonPropertyName("id")]
    public required string Id { get; set; }

    /// <summary>Model override for this agent, if set.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("model")]
    public string? Model { get; set; }

    /// <summary>Whether authored models are preferences or required constraints.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("modelPolicy")]
    public AgentModelPolicy? ModelPolicy { get; set; }

    /// <summary>Authored model ids in priority order, if configured.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("models")]
    public string[]? Models { get; set; }

    /// <summary>Internal name of the agent.</summary>
    [JsonPropertyName("name")]
    public required string Name { get; set; }

    /// <summary>Source location: user, project, inherited, remote, or plugin.</summary>
    [JsonPropertyName("source")]
    public required string Source { get; set; }

    /// <summary>List of tool names available to this agent, or null when all tools are available.</summary>
    [JsonPropertyName("tools")]
    public string[]? Tools { get; set; }

    /// <summary>Whether the agent can be selected by the user.</summary>
    [JsonPropertyName("userInvocable")]
    public required bool UserInvocable { get; set; }
}

/// <summary>Server-advertised metadata learned through modern discovery or legacy initialization.</summary>
/// <remarks>Nested data type for <c>McpServerMetadata</c>.</remarks>
public sealed partial class McpServerMetadata
{
    /// <summary>Non-empty natural-language guidance for using the server, or null when the server omitted instructions or advertised an empty string.</summary>
    [JsonPropertyName("instructions")]
    public string? Instructions { get; set; }
}

/// <summary>A single MCP server status summary in `session.mcp_servers_loaded`, including name, status, source, transport, and plugin metadata.</summary>
/// <remarks>Nested data type for <c>McpServersLoadedServer</c>.</remarks>
public sealed partial class McpServersLoadedServer
{
    /// <summary>Error message if the server failed to connect.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("error")]
    public string? Error { get; set; }

    /// <summary>Server name (config key).</summary>
    [JsonPropertyName("name")]
    public required string Name { get; set; }

    /// <summary>Name of the plugin that supplied the effective MCP server config, only when source is plugin.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("pluginName")]
    public string? PluginName { get; set; }

    /// <summary>Version of the plugin that supplied the effective MCP server config, only when source is plugin.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("pluginVersion")]
    public string? PluginVersion { get; set; }

    /// <summary>Server-advertised metadata for a connected server. Omitted when no live connection metadata is available, including while pending or when failed, disabled, stopped, or not configured.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("serverMetadata")]
    public McpServerMetadata? ServerMetadata { get; set; }

    /// <summary>Configuration source: user, workspace, plugin, or builtin.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("source")]
    public McpServerSource? Source { get; set; }

    /// <summary>Connection status: connected, failed, needs-auth, pending, disabled, stopped, or not_configured.</summary>
    [JsonPropertyName("status")]
    public required McpServerStatus Status { get; set; }

    /// <summary>Transport mechanism: stdio, http, sse (deprecated), or memory (in-process MCP server).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("transport")]
    public McpServerTransport? Transport { get; set; }
}

/// <summary>A single extension discovered by `session.extensions_loaded`, including qualified ID, source, and current status.</summary>
/// <remarks>Nested data type for <c>ExtensionsLoadedExtension</c>.</remarks>
public sealed partial class ExtensionsLoadedExtension
{
    /// <summary>Source-qualified extension ID (e.g., 'project:my-ext', 'user:auth-helper', 'plugin:my-plugin:my-ext').</summary>
    [JsonPropertyName("id")]
    public required string Id { get; set; }

    /// <summary>Extension name (directory name).</summary>
    [JsonPropertyName("name")]
    public required string Name { get; set; }

    /// <summary>Discovery source.</summary>
    [JsonPropertyName("source")]
    public required ExtensionsLoadedExtensionSource Source { get; set; }

    /// <summary>Current status: running, disabled, failed, or starting.</summary>
    [JsonPropertyName("status")]
    public required ExtensionsLoadedExtensionStatus Status { get; set; }
}

/// <summary>A single action within a canvas declaration, with its name, optional description, and optional input schema.</summary>
/// <remarks>Nested data type for <c>CanvasRegistryChangedCanvasAction</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
public sealed partial class CanvasRegistryChangedCanvasAction
{
    /// <summary>Action description.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("description")]
    public string? Description { get; set; }

    /// <summary>JSON Schema for action input.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("inputSchema")]
    public JsonElement? InputSchema { get; set; }

    /// <summary>Action name.</summary>
    [JsonPropertyName("name")]
    public required string Name { get; set; }
}

/// <summary>A single canvas declaration in `session.canvas.registry_changed`, including provider IDs, display metadata, input schema, and actions.</summary>
/// <remarks>Nested data type for <c>CanvasRegistryChangedCanvas</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
public sealed partial class CanvasRegistryChangedCanvas
{
    /// <summary>Actions the agent or host may invoke.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("actions")]
    public CanvasRegistryChangedCanvasAction[]? Actions { get; set; }

    /// <summary>Provider-local canvas identifier.</summary>
    [JsonPropertyName("canvasId")]
    public required string CanvasId { get; set; }

    /// <summary>Short, single-sentence description shown to the agent in canvas catalogs.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("description")]
    public required string Description { get; set; }

    /// <summary>Human-readable canvas name.</summary>
    [JsonPropertyName("displayName")]
    public required string DisplayName { get; set; }

    /// <summary>Owning provider identifier.</summary>
    [JsonPropertyName("extensionId")]
    public required string ExtensionId { get; set; }

    /// <summary>Owning extension display name, when available.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("extensionName")]
    public string? ExtensionName { get; set; }

    /// <summary>Host-local PNG path for the canvas icon, when supplied.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("icon")]
    public string? Icon { get; set; }

    /// <summary>JSON Schema for canvas open input.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("inputSchema")]
    public JsonElement? InputSchema { get; set; }
}

/// <summary>Set when the underlying tools/call threw an error before returning a CallToolResult.</summary>
/// <remarks>Nested data type for <c>McpAppToolCallCompleteError</c>.</remarks>
public sealed partial class McpAppToolCallCompleteError
{
    /// <summary>Human-readable error message.</summary>
    [JsonPropertyName("message")]
    public required string Message { get; set; }
}

/// <summary>MCP App tool `_meta.ui` resource URI and SEP-1865 visibility captured with an `mcp_app.tool_call_complete` result.</summary>
/// <remarks>Nested data type for <c>McpAppToolCallCompleteToolMetaUI</c>.</remarks>
public sealed partial class McpAppToolCallCompleteToolMetaUI
{
    /// <summary>`ui://` URI declared by the tool's `_meta.ui.resourceUri`.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("resourceUri")]
    public string? ResourceUri { get; set; }

    /// <summary>Tool visibility per SEP-1865 (typically a subset of `["model","app"]`).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("visibility")]
    public string[]? Visibility { get; set; }
}

/// <summary>The tool's `_meta.ui` block at the time of the call, so consumers can decide whether to forward the result to the model without re-listing tools.</summary>
/// <remarks>Nested data type for <c>McpAppToolCallCompleteToolMeta</c>.</remarks>
public sealed partial class McpAppToolCallCompleteToolMeta
{
    /// <summary>MCP App tool `_meta.ui` resource URI and SEP-1865 visibility captured with an `mcp_app.tool_call_complete` result.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("ui")]
    public McpAppToolCallCompleteToolMetaUI? Ui { get; set; }
}

/// <summary>Routing preference used when the session model is `auto`.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct AutoTier : IEquatable<AutoTier>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="AutoTier"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="AutoTier"/>.</param>
    [JsonConstructor]
    public AutoTier(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="AutoTier"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Optimize for efficiency.</summary>
    public static AutoTier Efficiency { get; } = new("efficiency");

    /// <summary>Balance efficiency and intelligence.</summary>
    public static AutoTier Balance { get; } = new("balance");

    /// <summary>Optimize for intelligence.</summary>
    public static AutoTier Intelligence { get; } = new("intelligence");

    /// <summary>Returns a value indicating whether two <see cref="AutoTier"/> instances are equivalent.</summary>
    public static bool operator ==(AutoTier left, AutoTier right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="AutoTier"/> instances are not equivalent.</summary>
    public static bool operator !=(AutoTier left, AutoTier right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is AutoTier other && Equals(other);

    /// <inheritdoc />
    public bool Equals(AutoTier other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{AutoTier}"/> for serializing <see cref="AutoTier"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<AutoTier>
    {
        /// <inheritdoc />
        public override AutoTier Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, AutoTier value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(AutoTier));
        }
    }
}

/// <summary>Hosting platform type of the repository (github or ado).</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct WorkingDirectoryContextHostType : IEquatable<WorkingDirectoryContextHostType>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="WorkingDirectoryContextHostType"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="WorkingDirectoryContextHostType"/>.</param>
    [JsonConstructor]
    public WorkingDirectoryContextHostType(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="WorkingDirectoryContextHostType"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Repository is hosted on GitHub.</summary>
    public static WorkingDirectoryContextHostType GitHub { get; } = new("github");

    /// <summary>Repository is hosted on Azure DevOps.</summary>
    public static WorkingDirectoryContextHostType Ado { get; } = new("ado");

    /// <summary>Returns a value indicating whether two <see cref="WorkingDirectoryContextHostType"/> instances are equivalent.</summary>
    public static bool operator ==(WorkingDirectoryContextHostType left, WorkingDirectoryContextHostType right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="WorkingDirectoryContextHostType"/> instances are not equivalent.</summary>
    public static bool operator !=(WorkingDirectoryContextHostType left, WorkingDirectoryContextHostType right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is WorkingDirectoryContextHostType other && Equals(other);

    /// <inheritdoc />
    public bool Equals(WorkingDirectoryContextHostType other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{WorkingDirectoryContextHostType}"/> for serializing <see cref="WorkingDirectoryContextHostType"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<WorkingDirectoryContextHostType>
    {
        /// <inheritdoc />
        public override WorkingDirectoryContextHostType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, WorkingDirectoryContextHostType value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(WorkingDirectoryContextHostType));
        }
    }
}

/// <summary>Allowed values for the `ContextTier` enumeration.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct ContextTier : IEquatable<ContextTier>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="ContextTier"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="ContextTier"/>.</param>
    [JsonConstructor]
    public ContextTier(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="ContextTier"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Default context tier with standard context window size.</summary>
    public static ContextTier Default { get; } = new("default");

    /// <summary>Extended context tier with a larger context window.</summary>
    public static ContextTier LongContext { get; } = new("long_context");

    /// <summary>Returns a value indicating whether two <see cref="ContextTier"/> instances are equivalent.</summary>
    public static bool operator ==(ContextTier left, ContextTier right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="ContextTier"/> instances are not equivalent.</summary>
    public static bool operator !=(ContextTier left, ContextTier right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is ContextTier other && Equals(other);

    /// <inheritdoc />
    public bool Equals(ContextTier other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{ContextTier}"/> for serializing <see cref="ContextTier"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<ContextTier>
    {
        /// <inheritdoc />
        public override ContextTier Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, ContextTier value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(ContextTier));
        }
    }
}

/// <summary>Reasoning summary mode used for model calls, if applicable (e.g. "none", "concise", "detailed").</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct ReasoningSummary : IEquatable<ReasoningSummary>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="ReasoningSummary"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="ReasoningSummary"/>.</param>
    [JsonConstructor]
    public ReasoningSummary(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="ReasoningSummary"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Do not request reasoning summaries from the model.</summary>
    public static ReasoningSummary None { get; } = new("none");

    /// <summary>Request a concise summary of the model's reasoning.</summary>
    public static ReasoningSummary Concise { get; } = new("concise");

    /// <summary>Request a detailed summary of the model's reasoning.</summary>
    public static ReasoningSummary Detailed { get; } = new("detailed");

    /// <summary>Returns a value indicating whether two <see cref="ReasoningSummary"/> instances are equivalent.</summary>
    public static bool operator ==(ReasoningSummary left, ReasoningSummary right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="ReasoningSummary"/> instances are not equivalent.</summary>
    public static bool operator !=(ReasoningSummary left, ReasoningSummary right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is ReasoningSummary other && Equals(other);

    /// <inheritdoc />
    public bool Equals(ReasoningSummary other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{ReasoningSummary}"/> for serializing <see cref="ReasoningSummary"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<ReasoningSummary>
    {
        /// <inheritdoc />
        public override ReasoningSummary Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, ReasoningSummary value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(ReasoningSummary));
        }
    }
}

/// <summary>Output verbosity level used for supported model calls (e.g. "low", "medium", "high").</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct Verbosity : IEquatable<Verbosity>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="Verbosity"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="Verbosity"/>.</param>
    [JsonConstructor]
    public Verbosity(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="Verbosity"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>A terse response was requested.</summary>
    public static Verbosity Low { get; } = new("low");

    /// <summary>A medium amount of response detail was requested.</summary>
    public static Verbosity Medium { get; } = new("medium");

    /// <summary>A more detailed response was requested.</summary>
    public static Verbosity High { get; } = new("high");

    /// <summary>Returns a value indicating whether two <see cref="Verbosity"/> instances are equivalent.</summary>
    public static bool operator ==(Verbosity left, Verbosity right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="Verbosity"/> instances are not equivalent.</summary>
    public static bool operator !=(Verbosity left, Verbosity right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is Verbosity other && Equals(other);

    /// <inheritdoc />
    public bool Equals(Verbosity other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{Verbosity}"/> for serializing <see cref="Verbosity"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<Verbosity>
    {
        /// <inheritdoc />
        public override Verbosity Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, Verbosity value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(Verbosity));
        }
    }
}

/// <summary>What the user must do to recover from a failure, named as an action rather than as one client's affordance. The runtime cannot know which affordance a client offers — a slash command, a settings pane, a link — so the accompanying message stays host-agnostic and each client renders its own copy from this value. Absent when the runtime knows of no action the user can take.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct RemediationAction : IEquatable<RemediationAction>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="RemediationAction"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="RemediationAction"/>.</param>
    [JsonConstructor]
    public RemediationAction(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="RemediationAction"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Authenticate again with the Copilot backend. The current credential is absent, expired, or rejected.</summary>
    public static RemediationAction SignIn { get; } = new("sign_in");

    /// <summary>Authenticate as a different account. The current account exists but lacks access to the requested resource.</summary>
    public static RemediationAction SwitchAccount { get; } = new("switch_account");

    /// <summary>Inspect which account is currently authenticated before deciding what to change.</summary>
    public static RemediationAction ShowAccount { get; } = new("show_account");

    /// <summary>Review or widen the sandbox policy. The blocked path or host is named by the accompanying message or by the tool result the action arrived with.</summary>
    public static RemediationAction ReviewSandboxPolicy { get; } = new("review_sandbox_policy");

    /// <summary>Permit outbound network access in the sandbox policy.</summary>
    public static RemediationAction AllowSandboxOutbound { get; } = new("allow_sandbox_outbound");

    /// <summary>Returns a value indicating whether two <see cref="RemediationAction"/> instances are equivalent.</summary>
    public static bool operator ==(RemediationAction left, RemediationAction right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="RemediationAction"/> instances are not equivalent.</summary>
    public static bool operator !=(RemediationAction left, RemediationAction right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is RemediationAction other && Equals(other);

    /// <inheritdoc />
    public bool Equals(RemediationAction other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{RemediationAction}"/> for serializing <see cref="RemediationAction"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<RemediationAction>
    {
        /// <inheritdoc />
        public override RemediationAction Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, RemediationAction value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(RemediationAction));
        }
    }
}

/// <summary>The session mode the agent is operating in.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct SessionMode : IEquatable<SessionMode>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="SessionMode"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="SessionMode"/>.</param>
    [JsonConstructor]
    public SessionMode(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="SessionMode"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The agent is responding interactively to the user.</summary>
    public static SessionMode Interactive { get; } = new("interactive");

    /// <summary>The agent is preparing a plan before making changes.</summary>
    public static SessionMode Plan { get; } = new("plan");

    /// <summary>The agent is working autonomously toward task completion.</summary>
    public static SessionMode Autopilot { get; } = new("autopilot");

    /// <summary>Returns a value indicating whether two <see cref="SessionMode"/> instances are equivalent.</summary>
    public static bool operator ==(SessionMode left, SessionMode right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="SessionMode"/> instances are not equivalent.</summary>
    public static bool operator !=(SessionMode left, SessionMode right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is SessionMode other && Equals(other);

    /// <inheritdoc />
    public bool Equals(SessionMode other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{SessionMode}"/> for serializing <see cref="SessionMode"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<SessionMode>
    {
        /// <inheritdoc />
        public override SessionMode Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, SessionMode value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(SessionMode));
        }
    }
}

/// <summary>Who created the schedule: `user` (an explicit user action such as `/every` or `/after`) or `model` (the agent via the `manage_schedule` tool). Gates whether a scheduled skill that opted out of model invocation may fire: only user-created schedules may.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct ScheduleOrigin : IEquatable<ScheduleOrigin>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="ScheduleOrigin"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="ScheduleOrigin"/>.</param>
    [JsonConstructor]
    public ScheduleOrigin(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="ScheduleOrigin"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The schedule was created by an explicit user action, such as `/every` or `/after`.</summary>
    public static ScheduleOrigin User { get; } = new("user");

    /// <summary>The schedule was created by the agent via the `manage_schedule` tool.</summary>
    public static ScheduleOrigin Model { get; } = new("model");

    /// <summary>Returns a value indicating whether two <see cref="ScheduleOrigin"/> instances are equivalent.</summary>
    public static bool operator ==(ScheduleOrigin left, ScheduleOrigin right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="ScheduleOrigin"/> instances are not equivalent.</summary>
    public static bool operator !=(ScheduleOrigin left, ScheduleOrigin right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is ScheduleOrigin other && Equals(other);

    /// <inheritdoc />
    public bool Equals(ScheduleOrigin other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{ScheduleOrigin}"/> for serializing <see cref="ScheduleOrigin"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<ScheduleOrigin>
    {
        /// <inheritdoc />
        public override ScheduleOrigin Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, ScheduleOrigin value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(ScheduleOrigin));
        }
    }
}

/// <summary>The type of operation performed on the autopilot objective state file.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct AutopilotObjectiveChangedOperation : IEquatable<AutopilotObjectiveChangedOperation>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="AutopilotObjectiveChangedOperation"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="AutopilotObjectiveChangedOperation"/>.</param>
    [JsonConstructor]
    public AutopilotObjectiveChangedOperation(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="AutopilotObjectiveChangedOperation"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Autopilot objective state file was created for a new objective.</summary>
    public static AutopilotObjectiveChangedOperation Create { get; } = new("create");

    /// <summary>Autopilot objective state file was updated for an existing objective.</summary>
    public static AutopilotObjectiveChangedOperation Update { get; } = new("update");

    /// <summary>Autopilot objective state file was deleted or cleared.</summary>
    public static AutopilotObjectiveChangedOperation Delete { get; } = new("delete");

    /// <summary>Returns a value indicating whether two <see cref="AutopilotObjectiveChangedOperation"/> instances are equivalent.</summary>
    public static bool operator ==(AutopilotObjectiveChangedOperation left, AutopilotObjectiveChangedOperation right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="AutopilotObjectiveChangedOperation"/> instances are not equivalent.</summary>
    public static bool operator !=(AutopilotObjectiveChangedOperation left, AutopilotObjectiveChangedOperation right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is AutopilotObjectiveChangedOperation other && Equals(other);

    /// <inheritdoc />
    public bool Equals(AutopilotObjectiveChangedOperation other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{AutopilotObjectiveChangedOperation}"/> for serializing <see cref="AutopilotObjectiveChangedOperation"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<AutopilotObjectiveChangedOperation>
    {
        /// <inheritdoc />
        public override AutopilotObjectiveChangedOperation Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, AutopilotObjectiveChangedOperation value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(AutopilotObjectiveChangedOperation));
        }
    }
}

/// <summary>Current autopilot objective status, if one exists.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct AutopilotObjectiveChangedStatus : IEquatable<AutopilotObjectiveChangedStatus>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="AutopilotObjectiveChangedStatus"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="AutopilotObjectiveChangedStatus"/>.</param>
    [JsonConstructor]
    public AutopilotObjectiveChangedStatus(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="AutopilotObjectiveChangedStatus"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Objective is active and can drive autopilot continuations.</summary>
    public static AutopilotObjectiveChangedStatus Active { get; } = new("active");

    /// <summary>Objective is paused and will not drive autopilot continuations.</summary>
    public static AutopilotObjectiveChangedStatus Paused { get; } = new("paused");

    /// <summary>Legacy objective state indicating the previous continuation cap was reached.</summary>
    public static AutopilotObjectiveChangedStatus CapReached { get; } = new("cap_reached");

    /// <summary>Objective was completed by the agent.</summary>
    public static AutopilotObjectiveChangedStatus Completed { get; } = new("completed");

    /// <summary>Returns a value indicating whether two <see cref="AutopilotObjectiveChangedStatus"/> instances are equivalent.</summary>
    public static bool operator ==(AutopilotObjectiveChangedStatus left, AutopilotObjectiveChangedStatus right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="AutopilotObjectiveChangedStatus"/> instances are not equivalent.</summary>
    public static bool operator !=(AutopilotObjectiveChangedStatus left, AutopilotObjectiveChangedStatus right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is AutopilotObjectiveChangedStatus other && Equals(other);

    /// <inheritdoc />
    public bool Equals(AutopilotObjectiveChangedStatus other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{AutopilotObjectiveChangedStatus}"/> for serializing <see cref="AutopilotObjectiveChangedStatus"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<AutopilotObjectiveChangedStatus>
    {
        /// <inheritdoc />
        public override AutopilotObjectiveChangedStatus Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, AutopilotObjectiveChangedStatus value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(AutopilotObjectiveChangedStatus));
        }
    }
}

/// <summary>Origin of an effective session model change.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct ModelChangeSource : IEquatable<ModelChangeSource>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="ModelChangeSource"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="ModelChangeSource"/>.</param>
    [JsonConstructor]
    public ModelChangeSource(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="ModelChangeSource"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The user selected a model directly with `/model &lt;id&gt;`.</summary>
    public static ModelChangeSource ModelCommand { get; } = new("model_command");

    /// <summary>The user selected the model with `/settings`.</summary>
    public static ModelChangeSource SettingsCommand { get; } = new("settings_command");

    /// <summary>The user selected the model with the `/config` alias.</summary>
    public static ModelChangeSource ConfigCommand { get; } = new("config_command");

    /// <summary>The user selected the model in the model picker, including the picker opened by bare `/model`.</summary>
    public static ModelChangeSource ModelPicker { get; } = new("model_picker");

    /// <summary>Organization-managed settings selected the model.</summary>
    public static ModelChangeSource ManagedSettings { get; } = new("managed_settings");

    /// <summary>Repository settings selected the model.</summary>
    public static ModelChangeSource RepoSettings { get; } = new("repo_settings");

    /// <summary>Startup model resolution selected the model.</summary>
    public static ModelChangeSource Startup { get; } = new("startup");

    /// <summary>Selecting an agent selected its configured model.</summary>
    public static ModelChangeSource Agent { get; } = new("agent");

    /// <summary>Entering, leaving, or reconfiguring plan mode selected the model.</summary>
    public static ModelChangeSource PlanMode { get; } = new("plan_mode");

    /// <summary>The runtime selected the model automatically, such as rate-limit recovery or refusal fallback.</summary>
    public static ModelChangeSource Automatic { get; } = new("automatic");

    /// <summary>An SDK or RPC caller selected the model.</summary>
    public static ModelChangeSource Sdk { get; } = new("sdk");

    /// <summary>Returns a value indicating whether two <see cref="ModelChangeSource"/> instances are equivalent.</summary>
    public static bool operator ==(ModelChangeSource left, ModelChangeSource right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="ModelChangeSource"/> instances are not equivalent.</summary>
    public static bool operator !=(ModelChangeSource left, ModelChangeSource right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is ModelChangeSource other && Equals(other);

    /// <inheritdoc />
    public bool Equals(ModelChangeSource other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{ModelChangeSource}"/> for serializing <see cref="ModelChangeSource"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<ModelChangeSource>
    {
        /// <inheritdoc />
        public override ModelChangeSource Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, ModelChangeSource value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(ModelChangeSource));
        }
    }
}

/// <summary>Terminal reason an Auto preference activation failed.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct AutoTierSwitchFailureReason : IEquatable<AutoTierSwitchFailureReason>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="AutoTierSwitchFailureReason"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="AutoTierSwitchFailureReason"/>.</param>
    [JsonConstructor]
    public AutoTierSwitchFailureReason(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="AutoTierSwitchFailureReason"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The candidate model was rejected by model policy.</summary>
    public static AutoTierSwitchFailureReason PolicyRejected { get; } = new("policy_rejected");

    /// <summary>The Auto routing request failed or returned an unusable response.</summary>
    public static AutoTierSwitchFailureReason RequestFailed { get; } = new("request_failed");

    /// <summary>The runtime could not prepare the Auto routing request.</summary>
    public static AutoTierSwitchFailureReason SetupFailed { get; } = new("setup_failed");

    /// <summary>The provider does not support Auto routing.</summary>
    public static AutoTierSwitchFailureReason Unsupported { get; } = new("unsupported");

    /// <summary>Returns a value indicating whether two <see cref="AutoTierSwitchFailureReason"/> instances are equivalent.</summary>
    public static bool operator ==(AutoTierSwitchFailureReason left, AutoTierSwitchFailureReason right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="AutoTierSwitchFailureReason"/> instances are not equivalent.</summary>
    public static bool operator !=(AutoTierSwitchFailureReason left, AutoTierSwitchFailureReason right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is AutoTierSwitchFailureReason other && Equals(other);

    /// <inheritdoc />
    public bool Equals(AutoTierSwitchFailureReason other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{AutoTierSwitchFailureReason}"/> for serializing <see cref="AutoTierSwitchFailureReason"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<AutoTierSwitchFailureReason>
    {
        /// <inheritdoc />
        public override AutoTierSwitchFailureReason Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, AutoTierSwitchFailureReason value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(AutoTierSwitchFailureReason));
        }
    }
}

/// <summary>Permission mode for the session.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct PermissionMode : IEquatable<PermissionMode>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="PermissionMode"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="PermissionMode"/>.</param>
    [JsonConstructor]
    public PermissionMode(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="PermissionMode"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Permission requests follow the normal approval flow.</summary>
    public static PermissionMode Manual { get; } = new("manual");

    /// <summary>Permission requests include an LLM safety recommendation; clients may automatically approve requests judged acceptable.</summary>
    public static PermissionMode Assisted { get; } = new("assisted");

    /// <summary>Tool, path, and URL permission requests are automatically approved.</summary>
    public static PermissionMode AllowAll { get; } = new("allow-all");

    /// <summary>Returns a value indicating whether two <see cref="PermissionMode"/> instances are equivalent.</summary>
    public static bool operator ==(PermissionMode left, PermissionMode right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="PermissionMode"/> instances are not equivalent.</summary>
    public static bool operator !=(PermissionMode left, PermissionMode right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is PermissionMode other && Equals(other);

    /// <inheritdoc />
    public bool Equals(PermissionMode other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{PermissionMode}"/> for serializing <see cref="PermissionMode"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<PermissionMode>
    {
        /// <inheritdoc />
        public override PermissionMode Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, PermissionMode value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(PermissionMode));
        }
    }
}

/// <summary>The type of operation performed on the plan file.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct PlanChangedOperation : IEquatable<PlanChangedOperation>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="PlanChangedOperation"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="PlanChangedOperation"/>.</param>
    [JsonConstructor]
    public PlanChangedOperation(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="PlanChangedOperation"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The plan file was created.</summary>
    public static PlanChangedOperation Create { get; } = new("create");

    /// <summary>The plan file was updated.</summary>
    public static PlanChangedOperation Update { get; } = new("update");

    /// <summary>The plan file was deleted.</summary>
    public static PlanChangedOperation Delete { get; } = new("delete");

    /// <summary>Returns a value indicating whether two <see cref="PlanChangedOperation"/> instances are equivalent.</summary>
    public static bool operator ==(PlanChangedOperation left, PlanChangedOperation right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="PlanChangedOperation"/> instances are not equivalent.</summary>
    public static bool operator !=(PlanChangedOperation left, PlanChangedOperation right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is PlanChangedOperation other && Equals(other);

    /// <inheritdoc />
    public bool Equals(PlanChangedOperation other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{PlanChangedOperation}"/> for serializing <see cref="PlanChangedOperation"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<PlanChangedOperation>
    {
        /// <inheritdoc />
        public override PlanChangedOperation Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, PlanChangedOperation value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(PlanChangedOperation));
        }
    }
}

/// <summary>Whether the file was newly created or updated.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct WorkspaceFileChangedOperation : IEquatable<WorkspaceFileChangedOperation>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="WorkspaceFileChangedOperation"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="WorkspaceFileChangedOperation"/>.</param>
    [JsonConstructor]
    public WorkspaceFileChangedOperation(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="WorkspaceFileChangedOperation"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The workspace file was created.</summary>
    public static WorkspaceFileChangedOperation Create { get; } = new("create");

    /// <summary>The workspace file was updated.</summary>
    public static WorkspaceFileChangedOperation Update { get; } = new("update");

    /// <summary>Returns a value indicating whether two <see cref="WorkspaceFileChangedOperation"/> instances are equivalent.</summary>
    public static bool operator ==(WorkspaceFileChangedOperation left, WorkspaceFileChangedOperation right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="WorkspaceFileChangedOperation"/> instances are not equivalent.</summary>
    public static bool operator !=(WorkspaceFileChangedOperation left, WorkspaceFileChangedOperation right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is WorkspaceFileChangedOperation other && Equals(other);

    /// <inheritdoc />
    public bool Equals(WorkspaceFileChangedOperation other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{WorkspaceFileChangedOperation}"/> for serializing <see cref="WorkspaceFileChangedOperation"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<WorkspaceFileChangedOperation>
    {
        /// <inheritdoc />
        public override WorkspaceFileChangedOperation Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, WorkspaceFileChangedOperation value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(WorkspaceFileChangedOperation));
        }
    }
}

/// <summary>Origin type of the session being handed off.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct HandoffSourceType : IEquatable<HandoffSourceType>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="HandoffSourceType"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="HandoffSourceType"/>.</param>
    [JsonConstructor]
    public HandoffSourceType(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="HandoffSourceType"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The handoff originated from a remote session.</summary>
    public static HandoffSourceType Remote { get; } = new("remote");

    /// <summary>The handoff originated from a local session.</summary>
    public static HandoffSourceType Local { get; } = new("local");

    /// <summary>Returns a value indicating whether two <see cref="HandoffSourceType"/> instances are equivalent.</summary>
    public static bool operator ==(HandoffSourceType left, HandoffSourceType right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="HandoffSourceType"/> instances are not equivalent.</summary>
    public static bool operator !=(HandoffSourceType left, HandoffSourceType right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is HandoffSourceType other && Equals(other);

    /// <inheritdoc />
    public bool Equals(HandoffSourceType other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{HandoffSourceType}"/> for serializing <see cref="HandoffSourceType"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<HandoffSourceType>
    {
        /// <inheritdoc />
        public override HandoffSourceType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, HandoffSourceType value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(HandoffSourceType));
        }
    }
}

/// <summary>Whether the session ended normally ("routine") or due to a crash/fatal error ("error").</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct ShutdownType : IEquatable<ShutdownType>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="ShutdownType"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="ShutdownType"/>.</param>
    [JsonConstructor]
    public ShutdownType(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="ShutdownType"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The session ended normally.</summary>
    public static ShutdownType Routine { get; } = new("routine");

    /// <summary>The session ended because of a crash or fatal error.</summary>
    public static ShutdownType Error { get; } = new("error");

    /// <summary>Returns a value indicating whether two <see cref="ShutdownType"/> instances are equivalent.</summary>
    public static bool operator ==(ShutdownType left, ShutdownType right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="ShutdownType"/> instances are not equivalent.</summary>
    public static bool operator !=(ShutdownType left, ShutdownType right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is ShutdownType other && Equals(other);

    /// <inheritdoc />
    public bool Equals(ShutdownType other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{ShutdownType}"/> for serializing <see cref="ShutdownType"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<ShutdownType>
    {
        /// <inheritdoc />
        public override ShutdownType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, ShutdownType value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(ShutdownType));
        }
    }
}

/// <summary>What initiated a conversation compaction.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct CompactionTrigger : IEquatable<CompactionTrigger>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="CompactionTrigger"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="CompactionTrigger"/>.</param>
    [JsonConstructor]
    public CompactionTrigger(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="CompactionTrigger"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Background compaction started automatically because context utilization crossed the background threshold.</summary>
    public static CompactionTrigger Threshold { get; } = new("threshold");

    /// <summary>Compaction forced by a context-limit model response (e.g. HTTP 413) before retrying the request.</summary>
    public static CompactionTrigger ContextLimitRetry { get; } = new("context_limit_retry");

    /// <summary>User-requested compaction, e.g. the /compact command or the history.compact API.</summary>
    public static CompactionTrigger Manual { get; } = new("manual");

    /// <summary>Emergency compaction triggered by high process memory usage.</summary>
    public static CompactionTrigger MemoryPressure { get; } = new("memory_pressure");

    /// <summary>Compaction requested while switching to a model with a smaller context window.</summary>
    public static CompactionTrigger ModelSwitch { get; } = new("model_switch");

    /// <summary>Returns a value indicating whether two <see cref="CompactionTrigger"/> instances are equivalent.</summary>
    public static bool operator ==(CompactionTrigger left, CompactionTrigger right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="CompactionTrigger"/> instances are not equivalent.</summary>
    public static bool operator !=(CompactionTrigger left, CompactionTrigger right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is CompactionTrigger other && Equals(other);

    /// <inheritdoc />
    public bool Equals(CompactionTrigger other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{CompactionTrigger}"/> for serializing <see cref="CompactionTrigger"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<CompactionTrigger>
    {
        /// <inheritdoc />
        public override CompactionTrigger Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, CompactionTrigger value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(CompactionTrigger));
        }
    }
}

/// <summary>Semantic result of evaluating a task completion request.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct TaskCompletionOutcome : IEquatable<TaskCompletionOutcome>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="TaskCompletionOutcome"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="TaskCompletionOutcome"/>.</param>
    [JsonConstructor]
    public TaskCompletionOutcome(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="TaskCompletionOutcome"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The completion request was accepted and the objective is complete.</summary>
    public static TaskCompletionOutcome Completed { get; } = new("completed");

    /// <summary>The completion request was rejected because more work or validation remains.</summary>
    public static TaskCompletionOutcome Continue { get; } = new("continue");

    /// <summary>Completion cannot proceed without intervention; the active objective is paused when one is identified.</summary>
    public static TaskCompletionOutcome Blocked { get; } = new("blocked");

    /// <summary>Returns a value indicating whether two <see cref="TaskCompletionOutcome"/> instances are equivalent.</summary>
    public static bool operator ==(TaskCompletionOutcome left, TaskCompletionOutcome right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="TaskCompletionOutcome"/> instances are not equivalent.</summary>
    public static bool operator !=(TaskCompletionOutcome left, TaskCompletionOutcome right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is TaskCompletionOutcome other && Equals(other);

    /// <inheritdoc />
    public bool Equals(TaskCompletionOutcome other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{TaskCompletionOutcome}"/> for serializing <see cref="TaskCompletionOutcome"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<TaskCompletionOutcome>
    {
        /// <inheritdoc />
        public override TaskCompletionOutcome Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, TaskCompletionOutcome value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(TaskCompletionOutcome));
        }
    }
}

/// <summary>Structured terminal status from a tool completion event.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct CompletionReceiptToolStatus : IEquatable<CompletionReceiptToolStatus>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="CompletionReceiptToolStatus"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="CompletionReceiptToolStatus"/>.</param>
    [JsonConstructor]
    public CompletionReceiptToolStatus(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="CompletionReceiptToolStatus"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The tool completed successfully.</summary>
    public static CompletionReceiptToolStatus Success { get; } = new("success");

    /// <summary>The tool failed without a more specific structured status.</summary>
    public static CompletionReceiptToolStatus Failure { get; } = new("failure");

    /// <summary>The tool exceeded its time budget.</summary>
    public static CompletionReceiptToolStatus Timeout { get; } = new("timeout");

    /// <summary>The user rejected the tool call.</summary>
    public static CompletionReceiptToolStatus Rejected { get; } = new("rejected");

    /// <summary>The permissions service denied the tool call.</summary>
    public static CompletionReceiptToolStatus Denied { get; } = new("denied");

    /// <summary>Returns a value indicating whether two <see cref="CompletionReceiptToolStatus"/> instances are equivalent.</summary>
    public static bool operator ==(CompletionReceiptToolStatus left, CompletionReceiptToolStatus right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="CompletionReceiptToolStatus"/> instances are not equivalent.</summary>
    public static bool operator !=(CompletionReceiptToolStatus left, CompletionReceiptToolStatus right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is CompletionReceiptToolStatus other && Equals(other);

    /// <inheritdoc />
    public bool Equals(CompletionReceiptToolStatus other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{CompletionReceiptToolStatus}"/> for serializing <see cref="CompletionReceiptToolStatus"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<CompletionReceiptToolStatus>
    {
        /// <inheritdoc />
        public override CompletionReceiptToolStatus Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, CompletionReceiptToolStatus value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(CompletionReceiptToolStatus));
        }
    }
}

/// <summary>Runtime reason the completion decision was accepted.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct CompletionReceiptStopReason : IEquatable<CompletionReceiptStopReason>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="CompletionReceiptStopReason"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="CompletionReceiptStopReason"/>.</param>
    [JsonConstructor]
    public CompletionReceiptStopReason(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="CompletionReceiptStopReason"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The model reached a natural terminal response.</summary>
    public static CompletionReceiptStopReason Natural { get; } = new("natural");

    /// <summary>A terminal tool ended the interaction.</summary>
    public static CompletionReceiptStopReason TerminalTool { get; } = new("terminal_tool");

    /// <summary>The configured agentStop continuation limit was reached.</summary>
    public static CompletionReceiptStopReason AgentStopBlockLimit { get; } = new("agent_stop_block_limit");

    /// <summary>Returns a value indicating whether two <see cref="CompletionReceiptStopReason"/> instances are equivalent.</summary>
    public static bool operator ==(CompletionReceiptStopReason left, CompletionReceiptStopReason right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="CompletionReceiptStopReason"/> instances are not equivalent.</summary>
    public static bool operator !=(CompletionReceiptStopReason left, CompletionReceiptStopReason right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is CompletionReceiptStopReason other && Equals(other);

    /// <inheritdoc />
    public bool Equals(CompletionReceiptStopReason other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{CompletionReceiptStopReason}"/> for serializing <see cref="CompletionReceiptStopReason"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<CompletionReceiptStopReason>
    {
        /// <inheritdoc />
        public override CompletionReceiptStopReason Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, CompletionReceiptStopReason value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(CompletionReceiptStopReason));
        }
    }
}

/// <summary>Kind of turn for which HydraFusion routing is running.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct FusionTurnKind : IEquatable<FusionTurnKind>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="FusionTurnKind"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="FusionTurnKind"/>.</param>
    [JsonConstructor]
    public FusionTurnKind(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="FusionTurnKind"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>A user-message turn.</summary>
    public static FusionTurnKind User { get; } = new("user");

    /// <summary>A conversation-compaction turn.</summary>
    public static FusionTurnKind Compaction { get; } = new("compaction");

    /// <summary>Returns a value indicating whether two <see cref="FusionTurnKind"/> instances are equivalent.</summary>
    public static bool operator ==(FusionTurnKind left, FusionTurnKind right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="FusionTurnKind"/> instances are not equivalent.</summary>
    public static bool operator !=(FusionTurnKind left, FusionTurnKind right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is FusionTurnKind other && Equals(other);

    /// <inheritdoc />
    public bool Equals(FusionTurnKind other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{FusionTurnKind}"/> for serializing <see cref="FusionTurnKind"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<FusionTurnKind>
    {
        /// <inheritdoc />
        public override FusionTurnKind Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, FusionTurnKind value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(FusionTurnKind));
        }
    }
}

/// <summary>Server-recommended routing behavior for a later HydraFusion turn.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct FusionFollowUpAction : IEquatable<FusionFollowUpAction>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="FusionFollowUpAction"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="FusionFollowUpAction"/>.</param>
    [JsonConstructor]
    public FusionFollowUpAction(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="FusionFollowUpAction"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Reuse the durable primary model without routing.</summary>
    public static FusionFollowUpAction ReusePrimary { get; } = new("reuse_primary");

    /// <summary>Request a new routing decision.</summary>
    public static FusionFollowUpAction Reroute { get; } = new("reroute");

    /// <summary>Returns a value indicating whether two <see cref="FusionFollowUpAction"/> instances are equivalent.</summary>
    public static bool operator ==(FusionFollowUpAction left, FusionFollowUpAction right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="FusionFollowUpAction"/> instances are not equivalent.</summary>
    public static bool operator !=(FusionFollowUpAction left, FusionFollowUpAction right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is FusionFollowUpAction other && Equals(other);

    /// <inheritdoc />
    public bool Equals(FusionFollowUpAction other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{FusionFollowUpAction}"/> for serializing <see cref="FusionFollowUpAction"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<FusionFollowUpAction>
    {
        /// <inheritdoc />
        public override FusionFollowUpAction Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, FusionFollowUpAction value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(FusionFollowUpAction));
        }
    }
}

/// <summary>Validated HydraFusion execution pattern.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct FusionPattern : IEquatable<FusionPattern>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="FusionPattern"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="FusionPattern"/>.</param>
    [JsonConstructor]
    public FusionPattern(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="FusionPattern"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Run one primary solver phase.</summary>
    public static FusionPattern Single { get; } = new("single");

    /// <summary>Run a primary phase, a judge, and an optional repair.</summary>
    public static FusionPattern Cascade { get; } = new("cascade");

    /// <summary>Run a primary draft, a read-only critique, and a revision.</summary>
    public static FusionPattern Critique { get; } = new("critique");

    /// <summary>Returns a value indicating whether two <see cref="FusionPattern"/> instances are equivalent.</summary>
    public static bool operator ==(FusionPattern left, FusionPattern right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="FusionPattern"/> instances are not equivalent.</summary>
    public static bool operator !=(FusionPattern left, FusionPattern right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is FusionPattern other && Equals(other);

    /// <inheritdoc />
    public bool Equals(FusionPattern other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{FusionPattern}"/> for serializing <see cref="FusionPattern"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<FusionPattern>
    {
        /// <inheritdoc />
        public override FusionPattern Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, FusionPattern value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(FusionPattern));
        }
    }
}

/// <summary>HydraFusion phase kind.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct FusionPhaseKind : IEquatable<FusionPhaseKind>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="FusionPhaseKind"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="FusionPhaseKind"/>.</param>
    [JsonConstructor]
    public FusionPhaseKind(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="FusionPhaseKind"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Primary solver phase.</summary>
    public static FusionPhaseKind Primary { get; } = new("primary");

    /// <summary>Read-only cascade judge phase.</summary>
    public static FusionPhaseKind Judge { get; } = new("judge");

    /// <summary>Cascade repair phase.</summary>
    public static FusionPhaseKind Repair { get; } = new("repair");

    /// <summary>Initial critique-pattern draft phase.</summary>
    public static FusionPhaseKind Draft { get; } = new("draft");

    /// <summary>Read-only critique phase.</summary>
    public static FusionPhaseKind Critic { get; } = new("critic");

    /// <summary>Critique-pattern revision phase.</summary>
    public static FusionPhaseKind Revision { get; } = new("revision");

    /// <summary>Follow-up phase continuing from the resolved model.</summary>
    public static FusionPhaseKind FollowUp { get; } = new("follow_up");

    /// <summary>Returns a value indicating whether two <see cref="FusionPhaseKind"/> instances are equivalent.</summary>
    public static bool operator ==(FusionPhaseKind left, FusionPhaseKind right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="FusionPhaseKind"/> instances are not equivalent.</summary>
    public static bool operator !=(FusionPhaseKind left, FusionPhaseKind right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is FusionPhaseKind other && Equals(other);

    /// <inheritdoc />
    public bool Equals(FusionPhaseKind other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{FusionPhaseKind}"/> for serializing <see cref="FusionPhaseKind"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<FusionPhaseKind>
    {
        /// <inheritdoc />
        public override FusionPhaseKind Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, FusionPhaseKind value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(FusionPhaseKind));
        }
    }
}

/// <summary>Conversation scope in which a HydraFusion phase executes.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct FusionConversationScope : IEquatable<FusionConversationScope>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="FusionConversationScope"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="FusionConversationScope"/>.</param>
    [JsonConstructor]
    public FusionConversationScope(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="FusionConversationScope"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Canonical root conversation history.</summary>
    public static FusionConversationScope Root { get; } = new("root");

    /// <summary>Isolated read-only review history that does not enter the root conversation.</summary>
    public static FusionConversationScope Review { get; } = new("review");

    /// <summary>Returns a value indicating whether two <see cref="FusionConversationScope"/> instances are equivalent.</summary>
    public static bool operator ==(FusionConversationScope left, FusionConversationScope right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="FusionConversationScope"/> instances are not equivalent.</summary>
    public static bool operator !=(FusionConversationScope left, FusionConversationScope right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is FusionConversationScope other && Equals(other);

    /// <inheritdoc />
    public bool Equals(FusionConversationScope other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{FusionConversationScope}"/> for serializing <see cref="FusionConversationScope"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<FusionConversationScope>
    {
        /// <inheritdoc />
        public override FusionConversationScope Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, FusionConversationScope value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(FusionConversationScope));
        }
    }
}

/// <summary>The agent mode that was active when this message was sent.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct UserMessageAgentMode : IEquatable<UserMessageAgentMode>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="UserMessageAgentMode"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="UserMessageAgentMode"/>.</param>
    [JsonConstructor]
    public UserMessageAgentMode(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="UserMessageAgentMode"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The agent is responding interactively to the user.</summary>
    public static UserMessageAgentMode Interactive { get; } = new("interactive");

    /// <summary>The agent is preparing a plan before making changes.</summary>
    public static UserMessageAgentMode Plan { get; } = new("plan");

    /// <summary>The agent is working autonomously toward task completion.</summary>
    public static UserMessageAgentMode Autopilot { get; } = new("autopilot");

    /// <summary>The agent is in shell-focused UI mode.</summary>
    public static UserMessageAgentMode Shell { get; } = new("shell");

    /// <summary>Returns a value indicating whether two <see cref="UserMessageAgentMode"/> instances are equivalent.</summary>
    public static bool operator ==(UserMessageAgentMode left, UserMessageAgentMode right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="UserMessageAgentMode"/> instances are not equivalent.</summary>
    public static bool operator !=(UserMessageAgentMode left, UserMessageAgentMode right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is UserMessageAgentMode other && Equals(other);

    /// <inheritdoc />
    public bool Equals(UserMessageAgentMode other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{UserMessageAgentMode}"/> for serializing <see cref="UserMessageAgentMode"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<UserMessageAgentMode>
    {
        /// <inheritdoc />
        public override UserMessageAgentMode Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, UserMessageAgentMode value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(UserMessageAgentMode));
        }
    }
}

/// <summary>Why the binary data is absent: it exceeded the inline size limit, or its asset was unavailable.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct OmittedBinaryOmittedReason : IEquatable<OmittedBinaryOmittedReason>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="OmittedBinaryOmittedReason"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="OmittedBinaryOmittedReason"/>.</param>
    [JsonConstructor]
    public OmittedBinaryOmittedReason(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="OmittedBinaryOmittedReason"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Bytes exceeded the session's inline size limit.</summary>
    public static OmittedBinaryOmittedReason TooLarge { get; } = new("too_large");

    /// <summary>The referenced binary asset could not be found (e.g. a truncated log).</summary>
    public static OmittedBinaryOmittedReason AssetUnavailable { get; } = new("asset_unavailable");

    /// <summary>Returns a value indicating whether two <see cref="OmittedBinaryOmittedReason"/> instances are equivalent.</summary>
    public static bool operator ==(OmittedBinaryOmittedReason left, OmittedBinaryOmittedReason right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="OmittedBinaryOmittedReason"/> instances are not equivalent.</summary>
    public static bool operator !=(OmittedBinaryOmittedReason left, OmittedBinaryOmittedReason right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is OmittedBinaryOmittedReason other && Equals(other);

    /// <inheritdoc />
    public bool Equals(OmittedBinaryOmittedReason other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{OmittedBinaryOmittedReason}"/> for serializing <see cref="OmittedBinaryOmittedReason"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<OmittedBinaryOmittedReason>
    {
        /// <inheritdoc />
        public override OmittedBinaryOmittedReason Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, OmittedBinaryOmittedReason value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(OmittedBinaryOmittedReason));
        }
    }
}

/// <summary>Type of GitHub reference.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct AttachmentGitHubReferenceType : IEquatable<AttachmentGitHubReferenceType>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="AttachmentGitHubReferenceType"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="AttachmentGitHubReferenceType"/>.</param>
    [JsonConstructor]
    public AttachmentGitHubReferenceType(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="AttachmentGitHubReferenceType"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>GitHub issue reference.</summary>
    public static AttachmentGitHubReferenceType Issue { get; } = new("issue");

    /// <summary>GitHub pull request reference.</summary>
    public static AttachmentGitHubReferenceType Pr { get; } = new("pr");

    /// <summary>GitHub discussion reference.</summary>
    public static AttachmentGitHubReferenceType Discussion { get; } = new("discussion");

    /// <summary>Returns a value indicating whether two <see cref="AttachmentGitHubReferenceType"/> instances are equivalent.</summary>
    public static bool operator ==(AttachmentGitHubReferenceType left, AttachmentGitHubReferenceType right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="AttachmentGitHubReferenceType"/> instances are not equivalent.</summary>
    public static bool operator !=(AttachmentGitHubReferenceType left, AttachmentGitHubReferenceType right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is AttachmentGitHubReferenceType other && Equals(other);

    /// <inheritdoc />
    public bool Equals(AttachmentGitHubReferenceType other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{AttachmentGitHubReferenceType}"/> for serializing <see cref="AttachmentGitHubReferenceType"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<AttachmentGitHubReferenceType>
    {
        /// <inheritdoc />
        public override AttachmentGitHubReferenceType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, AttachmentGitHubReferenceType value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(AttachmentGitHubReferenceType));
        }
    }
}

/// <summary>How this user message was delivered to the agentic loop, relative to whether the loop was already running. This is the timing axis only; the message's origin (human vs. system/command/schedule/skill/etc.) is carried separately by `source`. A system-injected message has a delivery too — e.g. a background-task notification waking an idle agent is `idle`, the same mechanism as a human starting a fresh turn.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct UserMessageDelivery : IEquatable<UserMessageDelivery>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="UserMessageDelivery"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="UserMessageDelivery"/>.</param>
    [JsonConstructor]
    public UserMessageDelivery(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="UserMessageDelivery"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Delivered while the loop was idle; starts its own run immediately (a human's fresh turn, or a system notification waking an idle agent).</summary>
    public static UserMessageDelivery Idle { get; } = new("idle");

    /// <summary>Injected into the current in-flight run while the agent was busy (immediate mode).</summary>
    public static UserMessageDelivery Steering { get; } = new("steering");

    /// <summary>Enqueued while the agent was busy; processed as its own run afterward.</summary>
    public static UserMessageDelivery Queued { get; } = new("queued");

    /// <summary>Returns a value indicating whether two <see cref="UserMessageDelivery"/> instances are equivalent.</summary>
    public static bool operator ==(UserMessageDelivery left, UserMessageDelivery right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="UserMessageDelivery"/> instances are not equivalent.</summary>
    public static bool operator !=(UserMessageDelivery left, UserMessageDelivery right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is UserMessageDelivery other && Equals(other);

    /// <inheritdoc />
    public bool Equals(UserMessageDelivery other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{UserMessageDelivery}"/> for serializing <see cref="UserMessageDelivery"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<UserMessageDelivery>
    {
        /// <inheritdoc />
        public override UserMessageDelivery Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, UserMessageDelivery value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(UserMessageDelivery));
        }
    }
}

/// <summary>What the agent was doing when the user interrupted it.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct AgentInterruptedActivity : IEquatable<AgentInterruptedActivity>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="AgentInterruptedActivity"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="AgentInterruptedActivity"/>.</param>
    [JsonConstructor]
    public AgentInterruptedActivity(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="AgentInterruptedActivity"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>A request to the model was open.</summary>
    public static AgentInterruptedActivity ModelCall { get; } = new("model_call");

    /// <summary>The turn was sleeping between retry attempts.</summary>
    public static AgentInterruptedActivity RetryBackoff { get; } = new("retry_backoff");

    /// <summary>One or more tools were executing.</summary>
    public static AgentInterruptedActivity ToolCall { get; } = new("tool_call");

    /// <summary>Background sub-agents were running while the main loop was idle.</summary>
    public static AgentInterruptedActivity BackgroundAgent { get; } = new("background_agent");

    /// <summary>Returns a value indicating whether two <see cref="AgentInterruptedActivity"/> instances are equivalent.</summary>
    public static bool operator ==(AgentInterruptedActivity left, AgentInterruptedActivity right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="AgentInterruptedActivity"/> instances are not equivalent.</summary>
    public static bool operator !=(AgentInterruptedActivity left, AgentInterruptedActivity right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is AgentInterruptedActivity other && Equals(other);

    /// <inheritdoc />
    public bool Equals(AgentInterruptedActivity other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{AgentInterruptedActivity}"/> for serializing <see cref="AgentInterruptedActivity"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<AgentInterruptedActivity>
    {
        /// <inheritdoc />
        public override AgentInterruptedActivity Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, AgentInterruptedActivity value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(AgentInterruptedActivity));
        }
    }
}

/// <summary>Where the interruption landed relative to the first streamed token.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct AgentInterruptedCancelPhase : IEquatable<AgentInterruptedCancelPhase>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="AgentInterruptedCancelPhase"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="AgentInterruptedCancelPhase"/>.</param>
    [JsonConstructor]
    public AgentInterruptedCancelPhase(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="AgentInterruptedCancelPhase"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>No output had been produced when the request was cancelled.</summary>
    public static AgentInterruptedCancelPhase PreFirstToken { get; } = new("pre_first_token");

    /// <summary>The response was already streaming when the request was cancelled.</summary>
    public static AgentInterruptedCancelPhase MidStream { get; } = new("mid_stream");

    /// <summary>Returns a value indicating whether two <see cref="AgentInterruptedCancelPhase"/> instances are equivalent.</summary>
    public static bool operator ==(AgentInterruptedCancelPhase left, AgentInterruptedCancelPhase right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="AgentInterruptedCancelPhase"/> instances are not equivalent.</summary>
    public static bool operator !=(AgentInterruptedCancelPhase left, AgentInterruptedCancelPhase right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is AgentInterruptedCancelPhase other && Equals(other);

    /// <inheritdoc />
    public bool Equals(AgentInterruptedCancelPhase other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{AgentInterruptedCancelPhase}"/> for serializing <see cref="AgentInterruptedCancelPhase"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<AgentInterruptedCancelPhase>
    {
        /// <inheritdoc />
        public override AgentInterruptedCancelPhase Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, AgentInterruptedCancelPhase value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(AgentInterruptedCancelPhase));
        }
    }
}

/// <summary>Transport used for a failed model call.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct ModelCallFailureTransport : IEquatable<ModelCallFailureTransport>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="ModelCallFailureTransport"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="ModelCallFailureTransport"/>.</param>
    [JsonConstructor]
    public ModelCallFailureTransport(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="ModelCallFailureTransport"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>HTTP transport, including SSE streams.</summary>
    public static ModelCallFailureTransport Http { get; } = new("http");

    /// <summary>WebSocket transport.</summary>
    public static ModelCallFailureTransport Websocket { get; } = new("websocket");

    /// <summary>Returns a value indicating whether two <see cref="ModelCallFailureTransport"/> instances are equivalent.</summary>
    public static bool operator ==(ModelCallFailureTransport left, ModelCallFailureTransport right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="ModelCallFailureTransport"/> instances are not equivalent.</summary>
    public static bool operator !=(ModelCallFailureTransport left, ModelCallFailureTransport right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is ModelCallFailureTransport other && Equals(other);

    /// <inheritdoc />
    public bool Equals(ModelCallFailureTransport other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{ModelCallFailureTransport}"/> for serializing <see cref="ModelCallFailureTransport"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<ModelCallFailureTransport>
    {
        /// <inheritdoc />
        public override ModelCallFailureTransport Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, ModelCallFailureTransport value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(ModelCallFailureTransport));
        }
    }
}

/// <summary>Content-safe activity observed while a HydraFusion phase is running.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct FusionPhaseActivityKind : IEquatable<FusionPhaseActivityKind>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="FusionPhaseActivityKind"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="FusionPhaseActivityKind"/>.</param>
    [JsonConstructor]
    public FusionPhaseActivityKind(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="FusionPhaseActivityKind"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The provider produced additional private output bytes.</summary>
    public static FusionPhaseActivityKind ModelOutput { get; } = new("model_output");

    /// <summary>A tool began executing inside the phase.</summary>
    public static FusionPhaseActivityKind ToolStarted { get; } = new("tool_started");

    /// <summary>A tool finished executing inside the phase.</summary>
    public static FusionPhaseActivityKind ToolCompleted { get; } = new("tool_completed");

    /// <summary>Returns a value indicating whether two <see cref="FusionPhaseActivityKind"/> instances are equivalent.</summary>
    public static bool operator ==(FusionPhaseActivityKind left, FusionPhaseActivityKind right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="FusionPhaseActivityKind"/> instances are not equivalent.</summary>
    public static bool operator !=(FusionPhaseActivityKind left, FusionPhaseActivityKind right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is FusionPhaseActivityKind other && Equals(other);

    /// <inheritdoc />
    public bool Equals(FusionPhaseActivityKind other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{FusionPhaseActivityKind}"/> for serializing <see cref="FusionPhaseActivityKind"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<FusionPhaseActivityKind>
    {
        /// <inheritdoc />
        public override FusionPhaseActivityKind Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, FusionPhaseActivityKind value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(FusionPhaseActivityKind));
        }
    }
}

/// <summary>How a durable phase checkpoint contributes its exact message to canonical root history.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct FusionProjectionMode : IEquatable<FusionProjectionMode>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="FusionProjectionMode"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="FusionProjectionMode"/>.</param>
    [JsonConstructor]
    public FusionProjectionMode(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="FusionProjectionMode"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Append the exact root message immediately.</summary>
    public static FusionProjectionMode Append { get; } = new("append");

    /// <summary>Hold a terminal message outside canonical history until the final commit selects it.</summary>
    public static FusionProjectionMode Staged { get; } = new("staged");

    /// <summary>Do not project the checkpoint into root history.</summary>
    public static FusionProjectionMode None { get; } = new("none");

    /// <summary>Returns a value indicating whether two <see cref="FusionProjectionMode"/> instances are equivalent.</summary>
    public static bool operator ==(FusionProjectionMode left, FusionProjectionMode right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="FusionProjectionMode"/> instances are not equivalent.</summary>
    public static bool operator !=(FusionProjectionMode left, FusionProjectionMode right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is FusionProjectionMode other && Equals(other);

    /// <inheritdoc />
    public bool Equals(FusionProjectionMode other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{FusionProjectionMode}"/> for serializing <see cref="FusionProjectionMode"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<FusionProjectionMode>
    {
        /// <inheritdoc />
        public override FusionProjectionMode Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, FusionProjectionMode value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(FusionProjectionMode));
        }
    }
}

/// <summary>Durable outcome status of a HydraFusion phase.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct FusionPhaseStatus : IEquatable<FusionPhaseStatus>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="FusionPhaseStatus"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="FusionPhaseStatus"/>.</param>
    [JsonConstructor]
    public FusionPhaseStatus(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="FusionPhaseStatus"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The phase completed successfully.</summary>
    public static FusionPhaseStatus Succeeded { get; } = new("succeeded");

    /// <summary>The phase failed.</summary>
    public static FusionPhaseStatus Failed { get; } = new("failed");

    /// <summary>The phase was cancelled.</summary>
    public static FusionPhaseStatus Cancelled { get; } = new("cancelled");

    /// <summary>Returns a value indicating whether two <see cref="FusionPhaseStatus"/> instances are equivalent.</summary>
    public static bool operator ==(FusionPhaseStatus left, FusionPhaseStatus right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="FusionPhaseStatus"/> instances are not equivalent.</summary>
    public static bool operator !=(FusionPhaseStatus left, FusionPhaseStatus right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is FusionPhaseStatus other && Equals(other);

    /// <inheritdoc />
    public bool Equals(FusionPhaseStatus other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{FusionPhaseStatus}"/> for serializing <see cref="FusionPhaseStatus"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<FusionPhaseStatus>
    {
        /// <inheritdoc />
        public override FusionPhaseStatus Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, FusionPhaseStatus value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(FusionPhaseStatus));
        }
    }
}

/// <summary>Tool call type: "function" for standard tool calls, "custom" for grammar-based tool calls. Defaults to "function" when absent.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct AssistantMessageToolRequestType : IEquatable<AssistantMessageToolRequestType>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="AssistantMessageToolRequestType"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="AssistantMessageToolRequestType"/>.</param>
    [JsonConstructor]
    public AssistantMessageToolRequestType(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="AssistantMessageToolRequestType"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Standard function-style tool call.</summary>
    public static AssistantMessageToolRequestType Function { get; } = new("function");

    /// <summary>Custom grammar-based tool call.</summary>
    public static AssistantMessageToolRequestType Custom { get; } = new("custom");

    /// <summary>Returns a value indicating whether two <see cref="AssistantMessageToolRequestType"/> instances are equivalent.</summary>
    public static bool operator ==(AssistantMessageToolRequestType left, AssistantMessageToolRequestType right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="AssistantMessageToolRequestType"/> instances are not equivalent.</summary>
    public static bool operator !=(AssistantMessageToolRequestType left, AssistantMessageToolRequestType right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is AssistantMessageToolRequestType other && Equals(other);

    /// <inheritdoc />
    public bool Equals(AssistantMessageToolRequestType other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{AssistantMessageToolRequestType}"/> for serializing <see cref="AssistantMessageToolRequestType"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<AssistantMessageToolRequestType>
    {
        /// <inheritdoc />
        public override AssistantMessageToolRequestType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, AssistantMessageToolRequestType value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(AssistantMessageToolRequestType));
        }
    }
}

/// <summary>The system that produced a citation.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct CitationProvider : IEquatable<CitationProvider>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="CitationProvider"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="CitationProvider"/>.</param>
    [JsonConstructor]
    public CitationProvider(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="CitationProvider"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Citation produced by an Anthropic (Claude) model response.</summary>
    public static CitationProvider Anthropic { get; } = new("anthropic");

    /// <summary>Citation produced by an OpenAI model response.</summary>
    public static CitationProvider Openai { get; } = new("openai");

    /// <summary>Citation synthesized client-side by the runtime from tool output.</summary>
    public static CitationProvider Client { get; } = new("client");

    /// <summary>Returns a value indicating whether two <see cref="CitationProvider"/> instances are equivalent.</summary>
    public static bool operator ==(CitationProvider left, CitationProvider right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="CitationProvider"/> instances are not equivalent.</summary>
    public static bool operator !=(CitationProvider left, CitationProvider right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is CitationProvider other && Equals(other);

    /// <inheritdoc />
    public bool Equals(CitationProvider other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{CitationProvider}"/> for serializing <see cref="CitationProvider"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<CitationProvider>
    {
        /// <inheritdoc />
        public override CitationProvider Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, CitationProvider value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(CitationProvider));
        }
    }
}

/// <summary>Hosted program caller type.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct AssistantMessageToolRequestCallerType : IEquatable<AssistantMessageToolRequestCallerType>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="AssistantMessageToolRequestCallerType"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="AssistantMessageToolRequestCallerType"/>.</param>
    [JsonConstructor]
    public AssistantMessageToolRequestCallerType(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="AssistantMessageToolRequestCallerType"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Gets the <c>program</c> value.</summary>
    public static AssistantMessageToolRequestCallerType Program { get; } = new("program");

    /// <summary>Returns a value indicating whether two <see cref="AssistantMessageToolRequestCallerType"/> instances are equivalent.</summary>
    public static bool operator ==(AssistantMessageToolRequestCallerType left, AssistantMessageToolRequestCallerType right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="AssistantMessageToolRequestCallerType"/> instances are not equivalent.</summary>
    public static bool operator !=(AssistantMessageToolRequestCallerType left, AssistantMessageToolRequestCallerType right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is AssistantMessageToolRequestCallerType other && Equals(other);

    /// <inheritdoc />
    public bool Equals(AssistantMessageToolRequestCallerType other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{AssistantMessageToolRequestCallerType}"/> for serializing <see cref="AssistantMessageToolRequestCallerType"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<AssistantMessageToolRequestCallerType>
    {
        /// <inheritdoc />
        public override AssistantMessageToolRequestCallerType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, AssistantMessageToolRequestCallerType value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(AssistantMessageToolRequestCallerType));
        }
    }
}

/// <summary>API endpoint used for this model call, matching CAPI supported_endpoints vocabulary.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct AssistantUsageApiEndpoint : IEquatable<AssistantUsageApiEndpoint>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="AssistantUsageApiEndpoint"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="AssistantUsageApiEndpoint"/>.</param>
    [JsonConstructor]
    public AssistantUsageApiEndpoint(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="AssistantUsageApiEndpoint"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Chat Completions API endpoint.</summary>
    public static AssistantUsageApiEndpoint ChatCompletions { get; } = new("/chat/completions");

    /// <summary>Anthropic Messages API endpoint.</summary>
    public static AssistantUsageApiEndpoint V1Messages { get; } = new("/v1/messages");

    /// <summary>Responses API endpoint.</summary>
    public static AssistantUsageApiEndpoint Responses { get; } = new("/responses");

    /// <summary>WebSocket Responses API endpoint.</summary>
    public static AssistantUsageApiEndpoint WsResponses { get; } = new("ws:/responses");

    /// <summary>Returns a value indicating whether two <see cref="AssistantUsageApiEndpoint"/> instances are equivalent.</summary>
    public static bool operator ==(AssistantUsageApiEndpoint left, AssistantUsageApiEndpoint right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="AssistantUsageApiEndpoint"/> instances are not equivalent.</summary>
    public static bool operator !=(AssistantUsageApiEndpoint left, AssistantUsageApiEndpoint right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is AssistantUsageApiEndpoint other && Equals(other);

    /// <inheritdoc />
    public bool Equals(AssistantUsageApiEndpoint other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{AssistantUsageApiEndpoint}"/> for serializing <see cref="AssistantUsageApiEndpoint"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<AssistantUsageApiEndpoint>
    {
        /// <inheritdoc />
        public override AssistantUsageApiEndpoint Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, AssistantUsageApiEndpoint value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(AssistantUsageApiEndpoint));
        }
    }
}

/// <summary>Transport used for a successful model call.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct AssistantUsageTransport : IEquatable<AssistantUsageTransport>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="AssistantUsageTransport"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="AssistantUsageTransport"/>.</param>
    [JsonConstructor]
    public AssistantUsageTransport(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="AssistantUsageTransport"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>HTTP transport, including SSE streams.</summary>
    public static AssistantUsageTransport Http { get; } = new("http");

    /// <summary>WebSocket transport.</summary>
    public static AssistantUsageTransport Websocket { get; } = new("websocket");

    /// <summary>Returns a value indicating whether two <see cref="AssistantUsageTransport"/> instances are equivalent.</summary>
    public static bool operator ==(AssistantUsageTransport left, AssistantUsageTransport right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="AssistantUsageTransport"/> instances are not equivalent.</summary>
    public static bool operator !=(AssistantUsageTransport left, AssistantUsageTransport right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is AssistantUsageTransport other && Equals(other);

    /// <inheritdoc />
    public bool Equals(AssistantUsageTransport other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{AssistantUsageTransport}"/> for serializing <see cref="AssistantUsageTransport"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<AssistantUsageTransport>
    {
        /// <inheritdoc />
        public override AssistantUsageTransport Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, AssistantUsageTransport value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(AssistantUsageTransport));
        }
    }
}

/// <summary>For HTTP 400 failures only: whether the response carried a structured CAPI error envelope (structured_error, a deterministic validation failure) or no error body (bodyless, the transient gateway/proxy signature). Absent for non-400 failures.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct ModelCallFailureBadRequestKind : IEquatable<ModelCallFailureBadRequestKind>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="ModelCallFailureBadRequestKind"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="ModelCallFailureBadRequestKind"/>.</param>
    [JsonConstructor]
    public ModelCallFailureBadRequestKind(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="ModelCallFailureBadRequestKind"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The 400 response carried no error body (transient gateway/proxy signature).</summary>
    public static ModelCallFailureBadRequestKind Bodyless { get; } = new("bodyless");

    /// <summary>The 400 response carried a structured CAPI error envelope (deterministic validation failure).</summary>
    public static ModelCallFailureBadRequestKind StructuredError { get; } = new("structured_error");

    /// <summary>Returns a value indicating whether two <see cref="ModelCallFailureBadRequestKind"/> instances are equivalent.</summary>
    public static bool operator ==(ModelCallFailureBadRequestKind left, ModelCallFailureBadRequestKind right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="ModelCallFailureBadRequestKind"/> instances are not equivalent.</summary>
    public static bool operator !=(ModelCallFailureBadRequestKind left, ModelCallFailureBadRequestKind right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is ModelCallFailureBadRequestKind other && Equals(other);

    /// <inheritdoc />
    public bool Equals(ModelCallFailureBadRequestKind other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{ModelCallFailureBadRequestKind}"/> for serializing <see cref="ModelCallFailureBadRequestKind"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<ModelCallFailureBadRequestKind>
    {
        /// <inheritdoc />
        public override ModelCallFailureBadRequestKind Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, ModelCallFailureBadRequestKind value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(ModelCallFailureBadRequestKind));
        }
    }
}

/// <summary>Boundary that produced a model call failure.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct ModelCallFailureKind : IEquatable<ModelCallFailureKind>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="ModelCallFailureKind"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="ModelCallFailureKind"/>.</param>
    [JsonConstructor]
    public ModelCallFailureKind(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="ModelCallFailureKind"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The provider returned an API error response.</summary>
    public static ModelCallFailureKind Api { get; } = new("api");

    /// <summary>The request transport failed before a usable API response completed.</summary>
    public static ModelCallFailureKind Transport { get; } = new("transport");

    /// <summary>Returns a value indicating whether two <see cref="ModelCallFailureKind"/> instances are equivalent.</summary>
    public static bool operator ==(ModelCallFailureKind left, ModelCallFailureKind right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="ModelCallFailureKind"/> instances are not equivalent.</summary>
    public static bool operator !=(ModelCallFailureKind left, ModelCallFailureKind right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is ModelCallFailureKind other && Equals(other);

    /// <inheritdoc />
    public bool Equals(ModelCallFailureKind other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{ModelCallFailureKind}"/> for serializing <see cref="ModelCallFailureKind"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<ModelCallFailureKind>
    {
        /// <inheritdoc />
        public override ModelCallFailureKind Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, ModelCallFailureKind value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(ModelCallFailureKind));
        }
    }
}

/// <summary>Where the failed model call originated.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct ModelCallFailureSource : IEquatable<ModelCallFailureSource>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="ModelCallFailureSource"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="ModelCallFailureSource"/>.</param>
    [JsonConstructor]
    public ModelCallFailureSource(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="ModelCallFailureSource"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Model call from the top-level agent.</summary>
    public static ModelCallFailureSource TopLevel { get; } = new("top_level");

    /// <summary>Model call from a sub-agent.</summary>
    public static ModelCallFailureSource Subagent { get; } = new("subagent");

    /// <summary>Model call from MCP sampling.</summary>
    public static ModelCallFailureSource McpSampling { get; } = new("mcp_sampling");

    /// <summary>Returns a value indicating whether two <see cref="ModelCallFailureSource"/> instances are equivalent.</summary>
    public static bool operator ==(ModelCallFailureSource left, ModelCallFailureSource right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="ModelCallFailureSource"/> instances are not equivalent.</summary>
    public static bool operator !=(ModelCallFailureSource left, ModelCallFailureSource right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is ModelCallFailureSource other && Equals(other);

    /// <inheritdoc />
    public bool Equals(ModelCallFailureSource other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{ModelCallFailureSource}"/> for serializing <see cref="ModelCallFailureSource"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<ModelCallFailureSource>
    {
        /// <inheritdoc />
        public override ModelCallFailureSource Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, ModelCallFailureSource value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(ModelCallFailureSource));
        }
    }
}

/// <summary>Final outcome of one logical model dispatch after response acceptance processing.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct ModelCallFinishedOutcome : IEquatable<ModelCallFinishedOutcome>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="ModelCallFinishedOutcome"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="ModelCallFinishedOutcome"/>.</param>
    [JsonConstructor]
    public ModelCallFinishedOutcome(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="ModelCallFinishedOutcome"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The provider response was accepted for continued agent processing.</summary>
    public static ModelCallFinishedOutcome Success { get; } = new("success");

    /// <summary>The dispatch ended with a provider or transport error.</summary>
    public static ModelCallFinishedOutcome Error { get; } = new("error");

    /// <summary>The dispatch was cancelled before an accepted response was produced.</summary>
    public static ModelCallFinishedOutcome Cancelled { get; } = new("cancelled");

    /// <summary>The provider response was rejected during post-response acceptance processing.</summary>
    public static ModelCallFinishedOutcome Rejected { get; } = new("rejected");

    /// <summary>Returns a value indicating whether two <see cref="ModelCallFinishedOutcome"/> instances are equivalent.</summary>
    public static bool operator ==(ModelCallFinishedOutcome left, ModelCallFinishedOutcome right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="ModelCallFinishedOutcome"/> instances are not equivalent.</summary>
    public static bool operator !=(ModelCallFinishedOutcome left, ModelCallFinishedOutcome right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is ModelCallFinishedOutcome other && Equals(other);

    /// <inheritdoc />
    public bool Equals(ModelCallFinishedOutcome other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{ModelCallFinishedOutcome}"/> for serializing <see cref="ModelCallFinishedOutcome"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<ModelCallFinishedOutcome>
    {
        /// <inheritdoc />
        public override ModelCallFinishedOutcome Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, ModelCallFinishedOutcome value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(ModelCallFinishedOutcome));
        }
    }
}

/// <summary>Finite reason code describing why the current turn was aborted.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct AbortReason : IEquatable<AbortReason>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="AbortReason"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="AbortReason"/>.</param>
    [JsonConstructor]
    public AbortReason(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="AbortReason"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The local user requested the abort, for example by pressing Ctrl+C in the CLI.</summary>
    public static AbortReason UserInitiated { get; } = new("user_initiated");

    /// <summary>A remote command requested the abort.</summary>
    public static AbortReason RemoteCommand { get; } = new("remote_command");

    /// <summary>An MCP server delivered a user.abort notification.</summary>
    public static AbortReason UserAbort { get; } = new("user_abort");

    /// <summary>Autopilot stopped the run because the active objective reached its user-set --max-ai-credits limit.</summary>
    public static AbortReason AutopilotCreditLimit { get; } = new("autopilot_credit_limit");

    /// <summary>Returns a value indicating whether two <see cref="AbortReason"/> instances are equivalent.</summary>
    public static bool operator ==(AbortReason left, AbortReason right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="AbortReason"/> instances are not equivalent.</summary>
    public static bool operator !=(AbortReason left, AbortReason right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is AbortReason other && Equals(other);

    /// <inheritdoc />
    public bool Equals(AbortReason other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{AbortReason}"/> for serializing <see cref="AbortReason"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<AbortReason>
    {
        /// <inheritdoc />
        public override AbortReason Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, AbortReason value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(AbortReason));
        }
    }
}

/// <summary>Allowed values for the `ToolExecutionStartToolDescriptionMetaUIVisibility` enumeration.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct ToolExecutionStartToolDescriptionMetaUIVisibility : IEquatable<ToolExecutionStartToolDescriptionMetaUIVisibility>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="ToolExecutionStartToolDescriptionMetaUIVisibility"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="ToolExecutionStartToolDescriptionMetaUIVisibility"/>.</param>
    [JsonConstructor]
    public ToolExecutionStartToolDescriptionMetaUIVisibility(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="ToolExecutionStartToolDescriptionMetaUIVisibility"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Tool is callable by the model (LLM tool surface).</summary>
    public static ToolExecutionStartToolDescriptionMetaUIVisibility Model { get; } = new("model");

    /// <summary>Tool is callable by the MCP App view (iframe) via session.mcp.apps.callTool.</summary>
    public static ToolExecutionStartToolDescriptionMetaUIVisibility App { get; } = new("app");

    /// <summary>Returns a value indicating whether two <see cref="ToolExecutionStartToolDescriptionMetaUIVisibility"/> instances are equivalent.</summary>
    public static bool operator ==(ToolExecutionStartToolDescriptionMetaUIVisibility left, ToolExecutionStartToolDescriptionMetaUIVisibility right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="ToolExecutionStartToolDescriptionMetaUIVisibility"/> instances are not equivalent.</summary>
    public static bool operator !=(ToolExecutionStartToolDescriptionMetaUIVisibility left, ToolExecutionStartToolDescriptionMetaUIVisibility right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is ToolExecutionStartToolDescriptionMetaUIVisibility other && Equals(other);

    /// <inheritdoc />
    public bool Equals(ToolExecutionStartToolDescriptionMetaUIVisibility other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{ToolExecutionStartToolDescriptionMetaUIVisibility}"/> for serializing <see cref="ToolExecutionStartToolDescriptionMetaUIVisibility"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<ToolExecutionStartToolDescriptionMetaUIVisibility>
    {
        /// <inheritdoc />
        public override ToolExecutionStartToolDescriptionMetaUIVisibility Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, ToolExecutionStartToolDescriptionMetaUIVisibility value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(ToolExecutionStartToolDescriptionMetaUIVisibility));
        }
    }
}

/// <summary>Binary result type discriminator. Use "image" for images and "resource" for other binary data.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct PersistedBinaryImageType : IEquatable<PersistedBinaryImageType>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="PersistedBinaryImageType"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="PersistedBinaryImageType"/>.</param>
    [JsonConstructor]
    public PersistedBinaryImageType(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="PersistedBinaryImageType"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Binary image data.</summary>
    public static PersistedBinaryImageType Image { get; } = new("image");

    /// <summary>Other binary resource data.</summary>
    public static PersistedBinaryImageType Resource { get; } = new("resource");

    /// <summary>Returns a value indicating whether two <see cref="PersistedBinaryImageType"/> instances are equivalent.</summary>
    public static bool operator ==(PersistedBinaryImageType left, PersistedBinaryImageType right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="PersistedBinaryImageType"/> instances are not equivalent.</summary>
    public static bool operator !=(PersistedBinaryImageType left, PersistedBinaryImageType right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is PersistedBinaryImageType other && Equals(other);

    /// <inheritdoc />
    public bool Equals(PersistedBinaryImageType other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{PersistedBinaryImageType}"/> for serializing <see cref="PersistedBinaryImageType"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<PersistedBinaryImageType>
    {
        /// <inheritdoc />
        public override PersistedBinaryImageType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, PersistedBinaryImageType value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(PersistedBinaryImageType));
        }
    }
}

/// <summary>Binary result type discriminator. Use "image" for images and "resource" for other binary data.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct OmittedBinaryType : IEquatable<OmittedBinaryType>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="OmittedBinaryType"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="OmittedBinaryType"/>.</param>
    [JsonConstructor]
    public OmittedBinaryType(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="OmittedBinaryType"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Binary image data.</summary>
    public static OmittedBinaryType Image { get; } = new("image");

    /// <summary>Other binary resource data.</summary>
    public static OmittedBinaryType Resource { get; } = new("resource");

    /// <summary>Returns a value indicating whether two <see cref="OmittedBinaryType"/> instances are equivalent.</summary>
    public static bool operator ==(OmittedBinaryType left, OmittedBinaryType right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="OmittedBinaryType"/> instances are not equivalent.</summary>
    public static bool operator !=(OmittedBinaryType left, OmittedBinaryType right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is OmittedBinaryType other && Equals(other);

    /// <inheritdoc />
    public bool Equals(OmittedBinaryType other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{OmittedBinaryType}"/> for serializing <see cref="OmittedBinaryType"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<OmittedBinaryType>
    {
        /// <inheritdoc />
        public override OmittedBinaryType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, OmittedBinaryType value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(OmittedBinaryType));
        }
    }
}

/// <summary>Binary result type discriminator. Use "image" for images and "resource" for other binary data.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct BinaryAssetReferenceType : IEquatable<BinaryAssetReferenceType>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="BinaryAssetReferenceType"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="BinaryAssetReferenceType"/>.</param>
    [JsonConstructor]
    public BinaryAssetReferenceType(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="BinaryAssetReferenceType"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Binary image data.</summary>
    public static BinaryAssetReferenceType Image { get; } = new("image");

    /// <summary>Other binary resource data.</summary>
    public static BinaryAssetReferenceType Resource { get; } = new("resource");

    /// <summary>Returns a value indicating whether two <see cref="BinaryAssetReferenceType"/> instances are equivalent.</summary>
    public static bool operator ==(BinaryAssetReferenceType left, BinaryAssetReferenceType right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="BinaryAssetReferenceType"/> instances are not equivalent.</summary>
    public static bool operator !=(BinaryAssetReferenceType left, BinaryAssetReferenceType right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is BinaryAssetReferenceType other && Equals(other);

    /// <inheritdoc />
    public bool Equals(BinaryAssetReferenceType other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{BinaryAssetReferenceType}"/> for serializing <see cref="BinaryAssetReferenceType"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<BinaryAssetReferenceType>
    {
        /// <inheritdoc />
        public override BinaryAssetReferenceType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, BinaryAssetReferenceType value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(BinaryAssetReferenceType));
        }
    }
}

/// <summary>Theme variant this icon is intended for.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct ToolExecutionCompleteContentResourceLinkIconTheme : IEquatable<ToolExecutionCompleteContentResourceLinkIconTheme>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="ToolExecutionCompleteContentResourceLinkIconTheme"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="ToolExecutionCompleteContentResourceLinkIconTheme"/>.</param>
    [JsonConstructor]
    public ToolExecutionCompleteContentResourceLinkIconTheme(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="ToolExecutionCompleteContentResourceLinkIconTheme"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Icon intended for light themes.</summary>
    public static ToolExecutionCompleteContentResourceLinkIconTheme Light { get; } = new("light");

    /// <summary>Icon intended for dark themes.</summary>
    public static ToolExecutionCompleteContentResourceLinkIconTheme Dark { get; } = new("dark");

    /// <summary>Returns a value indicating whether two <see cref="ToolExecutionCompleteContentResourceLinkIconTheme"/> instances are equivalent.</summary>
    public static bool operator ==(ToolExecutionCompleteContentResourceLinkIconTheme left, ToolExecutionCompleteContentResourceLinkIconTheme right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="ToolExecutionCompleteContentResourceLinkIconTheme"/> instances are not equivalent.</summary>
    public static bool operator !=(ToolExecutionCompleteContentResourceLinkIconTheme left, ToolExecutionCompleteContentResourceLinkIconTheme right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is ToolExecutionCompleteContentResourceLinkIconTheme other && Equals(other);

    /// <inheritdoc />
    public bool Equals(ToolExecutionCompleteContentResourceLinkIconTheme other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{ToolExecutionCompleteContentResourceLinkIconTheme}"/> for serializing <see cref="ToolExecutionCompleteContentResourceLinkIconTheme"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<ToolExecutionCompleteContentResourceLinkIconTheme>
    {
        /// <inheritdoc />
        public override ToolExecutionCompleteContentResourceLinkIconTheme Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, ToolExecutionCompleteContentResourceLinkIconTheme value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(ToolExecutionCompleteContentResourceLinkIconTheme));
        }
    }
}

/// <summary>Allowed values for the `ToolExecutionCompleteToolDescriptionMetaUIVisibility` enumeration.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct ToolExecutionCompleteToolDescriptionMetaUIVisibility : IEquatable<ToolExecutionCompleteToolDescriptionMetaUIVisibility>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="ToolExecutionCompleteToolDescriptionMetaUIVisibility"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="ToolExecutionCompleteToolDescriptionMetaUIVisibility"/>.</param>
    [JsonConstructor]
    public ToolExecutionCompleteToolDescriptionMetaUIVisibility(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="ToolExecutionCompleteToolDescriptionMetaUIVisibility"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Tool is callable by the model (LLM tool surface).</summary>
    public static ToolExecutionCompleteToolDescriptionMetaUIVisibility Model { get; } = new("model");

    /// <summary>Tool is callable by the MCP App view (iframe) via session.mcp.apps.callTool.</summary>
    public static ToolExecutionCompleteToolDescriptionMetaUIVisibility App { get; } = new("app");

    /// <summary>Returns a value indicating whether two <see cref="ToolExecutionCompleteToolDescriptionMetaUIVisibility"/> instances are equivalent.</summary>
    public static bool operator ==(ToolExecutionCompleteToolDescriptionMetaUIVisibility left, ToolExecutionCompleteToolDescriptionMetaUIVisibility right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="ToolExecutionCompleteToolDescriptionMetaUIVisibility"/> instances are not equivalent.</summary>
    public static bool operator !=(ToolExecutionCompleteToolDescriptionMetaUIVisibility left, ToolExecutionCompleteToolDescriptionMetaUIVisibility right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is ToolExecutionCompleteToolDescriptionMetaUIVisibility other && Equals(other);

    /// <inheritdoc />
    public bool Equals(ToolExecutionCompleteToolDescriptionMetaUIVisibility other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{ToolExecutionCompleteToolDescriptionMetaUIVisibility}"/> for serializing <see cref="ToolExecutionCompleteToolDescriptionMetaUIVisibility"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<ToolExecutionCompleteToolDescriptionMetaUIVisibility>
    {
        /// <inheritdoc />
        public override ToolExecutionCompleteToolDescriptionMetaUIVisibility Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, ToolExecutionCompleteToolDescriptionMetaUIVisibility value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(ToolExecutionCompleteToolDescriptionMetaUIVisibility));
        }
    }
}

/// <summary>What triggered the skill invocation: `user-invoked` (explicit user action, such as via a slash command or UI affordance), `agent-invoked` (agent requested the skill), or `context-load` (loaded as part of another context, such as preloading skills configured on a custom agent or subagent).</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct SkillInvokedTrigger : IEquatable<SkillInvokedTrigger>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="SkillInvokedTrigger"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="SkillInvokedTrigger"/>.</param>
    [JsonConstructor]
    public SkillInvokedTrigger(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="SkillInvokedTrigger"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Skill invocation requested explicitly by the user, such as via a slash command or UI affordance.</summary>
    public static SkillInvokedTrigger UserInvoked { get; } = new("user-invoked");

    /// <summary>Skill invocation requested by the agent.</summary>
    public static SkillInvokedTrigger AgentInvoked { get; } = new("agent-invoked");

    /// <summary>Skill content loaded as part of another context, such as a configured custom agent or subagent.</summary>
    public static SkillInvokedTrigger ContextLoad { get; } = new("context-load");

    /// <summary>Returns a value indicating whether two <see cref="SkillInvokedTrigger"/> instances are equivalent.</summary>
    public static bool operator ==(SkillInvokedTrigger left, SkillInvokedTrigger right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="SkillInvokedTrigger"/> instances are not equivalent.</summary>
    public static bool operator !=(SkillInvokedTrigger left, SkillInvokedTrigger right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is SkillInvokedTrigger other && Equals(other);

    /// <inheritdoc />
    public bool Equals(SkillInvokedTrigger other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{SkillInvokedTrigger}"/> for serializing <see cref="SkillInvokedTrigger"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<SkillInvokedTrigger>
    {
        /// <inheritdoc />
        public override SkillInvokedTrigger Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, SkillInvokedTrigger value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(SkillInvokedTrigger));
        }
    }
}

/// <summary>Binary asset type discriminator. Use "image" for images and "resource" otherwise.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct BinaryAssetType : IEquatable<BinaryAssetType>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="BinaryAssetType"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="BinaryAssetType"/>.</param>
    [JsonConstructor]
    public BinaryAssetType(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="BinaryAssetType"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Binary image data.</summary>
    public static BinaryAssetType Image { get; } = new("image");

    /// <summary>Other binary resource data.</summary>
    public static BinaryAssetType Resource { get; } = new("resource");

    /// <summary>Returns a value indicating whether two <see cref="BinaryAssetType"/> instances are equivalent.</summary>
    public static bool operator ==(BinaryAssetType left, BinaryAssetType right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="BinaryAssetType"/> instances are not equivalent.</summary>
    public static bool operator !=(BinaryAssetType left, BinaryAssetType right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is BinaryAssetType other && Equals(other);

    /// <inheritdoc />
    public bool Equals(BinaryAssetType other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{BinaryAssetType}"/> for serializing <see cref="BinaryAssetType"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<BinaryAssetType>
    {
        /// <inheritdoc />
        public override BinaryAssetType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, BinaryAssetType value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(BinaryAssetType));
        }
    }
}

/// <summary>Message role: "system" for system prompts, "developer" for developer-injected instructions.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct SystemMessageRole : IEquatable<SystemMessageRole>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="SystemMessageRole"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="SystemMessageRole"/>.</param>
    [JsonConstructor]
    public SystemMessageRole(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="SystemMessageRole"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>System prompt message.</summary>
    public static SystemMessageRole System { get; } = new("system");

    /// <summary>Developer instruction message.</summary>
    public static SystemMessageRole Developer { get; } = new("developer");

    /// <summary>Returns a value indicating whether two <see cref="SystemMessageRole"/> instances are equivalent.</summary>
    public static bool operator ==(SystemMessageRole left, SystemMessageRole right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="SystemMessageRole"/> instances are not equivalent.</summary>
    public static bool operator !=(SystemMessageRole left, SystemMessageRole right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is SystemMessageRole other && Equals(other);

    /// <inheritdoc />
    public bool Equals(SystemMessageRole other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{SystemMessageRole}"/> for serializing <see cref="SystemMessageRole"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<SystemMessageRole>
    {
        /// <inheritdoc />
        public override SystemMessageRole Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, SystemMessageRole value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(SystemMessageRole));
        }
    }
}

/// <summary>Whether the agent completed successfully or failed.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct SystemNotificationAgentCompletedStatus : IEquatable<SystemNotificationAgentCompletedStatus>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="SystemNotificationAgentCompletedStatus"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="SystemNotificationAgentCompletedStatus"/>.</param>
    [JsonConstructor]
    public SystemNotificationAgentCompletedStatus(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="SystemNotificationAgentCompletedStatus"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The agent completed successfully.</summary>
    public static SystemNotificationAgentCompletedStatus Completed { get; } = new("completed");

    /// <summary>The agent failed.</summary>
    public static SystemNotificationAgentCompletedStatus Failed { get; } = new("failed");

    /// <summary>Returns a value indicating whether two <see cref="SystemNotificationAgentCompletedStatus"/> instances are equivalent.</summary>
    public static bool operator ==(SystemNotificationAgentCompletedStatus left, SystemNotificationAgentCompletedStatus right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="SystemNotificationAgentCompletedStatus"/> instances are not equivalent.</summary>
    public static bool operator !=(SystemNotificationAgentCompletedStatus left, SystemNotificationAgentCompletedStatus right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is SystemNotificationAgentCompletedStatus other && Equals(other);

    /// <inheritdoc />
    public bool Equals(SystemNotificationAgentCompletedStatus other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{SystemNotificationAgentCompletedStatus}"/> for serializing <see cref="SystemNotificationAgentCompletedStatus"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<SystemNotificationAgentCompletedStatus>
    {
        /// <inheritdoc />
        public override SystemNotificationAgentCompletedStatus Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, SystemNotificationAgentCompletedStatus value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(SystemNotificationAgentCompletedStatus));
        }
    }
}

/// <summary>Terminal status reached by a factory execution attempt.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct SystemNotificationFactoryCompletedStatus : IEquatable<SystemNotificationFactoryCompletedStatus>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="SystemNotificationFactoryCompletedStatus"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="SystemNotificationFactoryCompletedStatus"/>.</param>
    [JsonConstructor]
    public SystemNotificationFactoryCompletedStatus(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="SystemNotificationFactoryCompletedStatus"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The factory completed successfully.</summary>
    public static SystemNotificationFactoryCompletedStatus Completed { get; } = new("completed");

    /// <summary>The factory was halted.</summary>
    public static SystemNotificationFactoryCompletedStatus Halted { get; } = new("halted");

    /// <summary>The factory was cancelled.</summary>
    public static SystemNotificationFactoryCompletedStatus Cancelled { get; } = new("cancelled");

    /// <summary>The factory failed.</summary>
    public static SystemNotificationFactoryCompletedStatus Error { get; } = new("error");

    /// <summary>Returns a value indicating whether two <see cref="SystemNotificationFactoryCompletedStatus"/> instances are equivalent.</summary>
    public static bool operator ==(SystemNotificationFactoryCompletedStatus left, SystemNotificationFactoryCompletedStatus right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="SystemNotificationFactoryCompletedStatus"/> instances are not equivalent.</summary>
    public static bool operator !=(SystemNotificationFactoryCompletedStatus left, SystemNotificationFactoryCompletedStatus right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is SystemNotificationFactoryCompletedStatus other && Equals(other);

    /// <inheritdoc />
    public bool Equals(SystemNotificationFactoryCompletedStatus other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{SystemNotificationFactoryCompletedStatus}"/> for serializing <see cref="SystemNotificationFactoryCompletedStatus"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<SystemNotificationFactoryCompletedStatus>
    {
        /// <inheritdoc />
        public override SystemNotificationFactoryCompletedStatus Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, SystemNotificationFactoryCompletedStatus value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(SystemNotificationFactoryCompletedStatus));
        }
    }
}

/// <summary>Advisory recommendation the runtime attaches to a permission request whose origin it can vouch for by construction. Unlike the auto-approval judge this does not depend on auto mode and does not evaluate what the tool call does; its absence simply means the runtime has no opinion and the request follows the host's normal approval flow.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct PermissionRecommendation : IEquatable<PermissionRecommendation>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="PermissionRecommendation"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="PermissionRecommendation"/>.</param>
    [JsonConstructor]
    public PermissionRecommendation(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="PermissionRecommendation"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The runtime vouches for the request's origin and recommends approving it without prompting. The host still owns the decision and may deny it; deny rules, managed policy, and the auto-approval safety judge all outrank this recommendation.</summary>
    public static PermissionRecommendation Approve { get; } = new("approve");

    /// <summary>Returns a value indicating whether two <see cref="PermissionRecommendation"/> instances are equivalent.</summary>
    public static bool operator ==(PermissionRecommendation left, PermissionRecommendation right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="PermissionRecommendation"/> instances are not equivalent.</summary>
    public static bool operator !=(PermissionRecommendation left, PermissionRecommendation right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is PermissionRecommendation other && Equals(other);

    /// <inheritdoc />
    public bool Equals(PermissionRecommendation other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{PermissionRecommendation}"/> for serializing <see cref="PermissionRecommendation"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<PermissionRecommendation>
    {
        /// <inheritdoc />
        public override PermissionRecommendation Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, PermissionRecommendation value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(PermissionRecommendation));
        }
    }
}

/// <summary>Whether this is a store or vote memory operation.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct PermissionRequestMemoryAction : IEquatable<PermissionRequestMemoryAction>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="PermissionRequestMemoryAction"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="PermissionRequestMemoryAction"/>.</param>
    [JsonConstructor]
    public PermissionRequestMemoryAction(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="PermissionRequestMemoryAction"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Store a new memory.</summary>
    public static PermissionRequestMemoryAction Store { get; } = new("store");

    /// <summary>Vote on an existing memory.</summary>
    public static PermissionRequestMemoryAction Vote { get; } = new("vote");

    /// <summary>Returns a value indicating whether two <see cref="PermissionRequestMemoryAction"/> instances are equivalent.</summary>
    public static bool operator ==(PermissionRequestMemoryAction left, PermissionRequestMemoryAction right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="PermissionRequestMemoryAction"/> instances are not equivalent.</summary>
    public static bool operator !=(PermissionRequestMemoryAction left, PermissionRequestMemoryAction right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is PermissionRequestMemoryAction other && Equals(other);

    /// <inheritdoc />
    public bool Equals(PermissionRequestMemoryAction other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{PermissionRequestMemoryAction}"/> for serializing <see cref="PermissionRequestMemoryAction"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<PermissionRequestMemoryAction>
    {
        /// <inheritdoc />
        public override PermissionRequestMemoryAction Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, PermissionRequestMemoryAction value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(PermissionRequestMemoryAction));
        }
    }
}

/// <summary>Why the assisted-approval judge produced no usable recommendation. Present only alongside an `error` recommendation, where the human-readable reason is a fixed string and therefore cannot distinguish these cases. Intended to make a judge failure reportable by a consumer that has no access to the host's logs.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct AssistedApprovalJudgeFailureReason : IEquatable<AssistedApprovalJudgeFailureReason>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="AssistedApprovalJudgeFailureReason"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="AssistedApprovalJudgeFailureReason"/>.</param>
    [JsonConstructor]
    public AssistedApprovalJudgeFailureReason(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="AssistedApprovalJudgeFailureReason"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The judge model call exceeded its deadline.</summary>
    public static AssistedApprovalJudgeFailureReason Timeout { get; } = new("timeout");

    /// <summary>The judge model call was cancelled before it returned.</summary>
    public static AssistedApprovalJudgeFailureReason Abort { get; } = new("abort");

    /// <summary>The judge model call completed but returned no content.</summary>
    public static AssistedApprovalJudgeFailureReason EmptyResponse { get; } = new("empty_response");

    /// <summary>The judge model call failed (for example a transport, authentication, or rate-limit error).</summary>
    public static AssistedApprovalJudgeFailureReason ModelError { get; } = new("model_error");

    /// <summary>The judge model replied, but the reply carried no ALLOW/DENY verdict.</summary>
    public static AssistedApprovalJudgeFailureReason ParseError { get; } = new("parse_error");

    /// <summary>Returns a value indicating whether two <see cref="AssistedApprovalJudgeFailureReason"/> instances are equivalent.</summary>
    public static bool operator ==(AssistedApprovalJudgeFailureReason left, AssistedApprovalJudgeFailureReason right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="AssistedApprovalJudgeFailureReason"/> instances are not equivalent.</summary>
    public static bool operator !=(AssistedApprovalJudgeFailureReason left, AssistedApprovalJudgeFailureReason right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is AssistedApprovalJudgeFailureReason other && Equals(other);

    /// <inheritdoc />
    public bool Equals(AssistedApprovalJudgeFailureReason other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{AssistedApprovalJudgeFailureReason}"/> for serializing <see cref="AssistedApprovalJudgeFailureReason"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<AssistedApprovalJudgeFailureReason>
    {
        /// <inheritdoc />
        public override AssistedApprovalJudgeFailureReason Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, AssistedApprovalJudgeFailureReason value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(AssistedApprovalJudgeFailureReason));
        }
    }
}

/// <summary>Outcome of the assisted-approval safety judge for a permission request. Present only in assisted mode; its absence means the judge did not evaluate the request.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct AssistedApprovalRecommendation : IEquatable<AssistedApprovalRecommendation>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="AssistedApprovalRecommendation"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="AssistedApprovalRecommendation"/>.</param>
    [JsonConstructor]
    public AssistedApprovalRecommendation(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="AssistedApprovalRecommendation"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The judge evaluated the request and recommends automatically approving it.</summary>
    public static AssistedApprovalRecommendation Approve { get; } = new("approve");

    /// <summary>The judge evaluated the request and does not recommend automatically approving it; explicit approval is required. Whether that means prompting, denying, or something else is the consumer's decision.</summary>
    public static AssistedApprovalRecommendation RequireApproval { get; } = new("requireApproval");

    /// <summary>Assisted mode is enabled, but this request category is never automatically approvable (for example, sandbox-bypass requests), so the judge was not consulted.</summary>
    public static AssistedApprovalRecommendation Excluded { get; } = new("excluded");

    /// <summary>The judge was consulted but did not return a usable recommendation, so the request requires explicit approval.</summary>
    public static AssistedApprovalRecommendation Error { get; } = new("error");

    /// <summary>Returns a value indicating whether two <see cref="AssistedApprovalRecommendation"/> instances are equivalent.</summary>
    public static bool operator ==(AssistedApprovalRecommendation left, AssistedApprovalRecommendation right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="AssistedApprovalRecommendation"/> instances are not equivalent.</summary>
    public static bool operator !=(AssistedApprovalRecommendation left, AssistedApprovalRecommendation right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is AssistedApprovalRecommendation other && Equals(other);

    /// <inheritdoc />
    public bool Equals(AssistedApprovalRecommendation other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{AssistedApprovalRecommendation}"/> for serializing <see cref="AssistedApprovalRecommendation"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<AssistedApprovalRecommendation>
    {
        /// <inheritdoc />
        public override AssistedApprovalRecommendation Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, AssistedApprovalRecommendation value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(AssistedApprovalRecommendation));
        }
    }
}

/// <summary>Vote direction (vote only).</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct PermissionRequestMemoryDirection : IEquatable<PermissionRequestMemoryDirection>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="PermissionRequestMemoryDirection"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="PermissionRequestMemoryDirection"/>.</param>
    [JsonConstructor]
    public PermissionRequestMemoryDirection(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="PermissionRequestMemoryDirection"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Vote that the memory is useful or accurate.</summary>
    public static PermissionRequestMemoryDirection Upvote { get; } = new("upvote");

    /// <summary>Vote that the memory is incorrect or outdated.</summary>
    public static PermissionRequestMemoryDirection Downvote { get; } = new("downvote");

    /// <summary>Returns a value indicating whether two <see cref="PermissionRequestMemoryDirection"/> instances are equivalent.</summary>
    public static bool operator ==(PermissionRequestMemoryDirection left, PermissionRequestMemoryDirection right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="PermissionRequestMemoryDirection"/> instances are not equivalent.</summary>
    public static bool operator !=(PermissionRequestMemoryDirection left, PermissionRequestMemoryDirection right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is PermissionRequestMemoryDirection other && Equals(other);

    /// <inheritdoc />
    public bool Equals(PermissionRequestMemoryDirection other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{PermissionRequestMemoryDirection}"/> for serializing <see cref="PermissionRequestMemoryDirection"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<PermissionRequestMemoryDirection>
    {
        /// <inheritdoc />
        public override PermissionRequestMemoryDirection Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, PermissionRequestMemoryDirection value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(PermissionRequestMemoryDirection));
        }
    }
}

/// <summary>Scope of a stored memory.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct PermissionRequestMemoryScope : IEquatable<PermissionRequestMemoryScope>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="PermissionRequestMemoryScope"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="PermissionRequestMemoryScope"/>.</param>
    [JsonConstructor]
    public PermissionRequestMemoryScope(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="PermissionRequestMemoryScope"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Store the memory for the current repository.</summary>
    public static PermissionRequestMemoryScope Repository { get; } = new("repository");

    /// <summary>Store the memory for the current user.</summary>
    public static PermissionRequestMemoryScope User { get; } = new("user");

    /// <summary>Returns a value indicating whether two <see cref="PermissionRequestMemoryScope"/> instances are equivalent.</summary>
    public static bool operator ==(PermissionRequestMemoryScope left, PermissionRequestMemoryScope right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="PermissionRequestMemoryScope"/> instances are not equivalent.</summary>
    public static bool operator !=(PermissionRequestMemoryScope left, PermissionRequestMemoryScope right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is PermissionRequestMemoryScope other && Equals(other);

    /// <inheritdoc />
    public bool Equals(PermissionRequestMemoryScope other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{PermissionRequestMemoryScope}"/> for serializing <see cref="PermissionRequestMemoryScope"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<PermissionRequestMemoryScope>
    {
        /// <inheritdoc />
        public override PermissionRequestMemoryScope Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, PermissionRequestMemoryScope value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(PermissionRequestMemoryScope));
        }
    }
}

/// <summary>Operation gated by a factory permission request.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct FactoryPermissionOperation : IEquatable<FactoryPermissionOperation>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="FactoryPermissionOperation"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="FactoryPermissionOperation"/>.</param>
    [JsonConstructor]
    public FactoryPermissionOperation(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="FactoryPermissionOperation"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Running a registered factory, which spends subagents, active time, and AI credits under the approved limits.</summary>
    public static FactoryPermissionOperation Run { get; } = new("run");

    /// <summary>Authoring a factory, which writes JavaScript into a session-scoped extension and loads it.</summary>
    public static FactoryPermissionOperation Author { get; } = new("author");

    /// <summary>Returns a value indicating whether two <see cref="FactoryPermissionOperation"/> instances are equivalent.</summary>
    public static bool operator ==(FactoryPermissionOperation left, FactoryPermissionOperation right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="FactoryPermissionOperation"/> instances are not equivalent.</summary>
    public static bool operator !=(FactoryPermissionOperation left, FactoryPermissionOperation right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is FactoryPermissionOperation other && Equals(other);

    /// <inheritdoc />
    public bool Equals(FactoryPermissionOperation other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{FactoryPermissionOperation}"/> for serializing <see cref="FactoryPermissionOperation"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<FactoryPermissionOperation>
    {
        /// <inheritdoc />
        public override FactoryPermissionOperation Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, FactoryPermissionOperation value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(FactoryPermissionOperation));
        }
    }
}

/// <summary>Underlying permission kind that needs path approval.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct PermissionPromptRequestPathAccessKind : IEquatable<PermissionPromptRequestPathAccessKind>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="PermissionPromptRequestPathAccessKind"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="PermissionPromptRequestPathAccessKind"/>.</param>
    [JsonConstructor]
    public PermissionPromptRequestPathAccessKind(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="PermissionPromptRequestPathAccessKind"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Read access to a filesystem path.</summary>
    public static PermissionPromptRequestPathAccessKind Read { get; } = new("read");

    /// <summary>Shell command access involving a filesystem path.</summary>
    public static PermissionPromptRequestPathAccessKind Shell { get; } = new("shell");

    /// <summary>Write access to a filesystem path.</summary>
    public static PermissionPromptRequestPathAccessKind Write { get; } = new("write");

    /// <summary>Returns a value indicating whether two <see cref="PermissionPromptRequestPathAccessKind"/> instances are equivalent.</summary>
    public static bool operator ==(PermissionPromptRequestPathAccessKind left, PermissionPromptRequestPathAccessKind right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="PermissionPromptRequestPathAccessKind"/> instances are not equivalent.</summary>
    public static bool operator !=(PermissionPromptRequestPathAccessKind left, PermissionPromptRequestPathAccessKind right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is PermissionPromptRequestPathAccessKind other && Equals(other);

    /// <inheritdoc />
    public bool Equals(PermissionPromptRequestPathAccessKind other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{PermissionPromptRequestPathAccessKind}"/> for serializing <see cref="PermissionPromptRequestPathAccessKind"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<PermissionPromptRequestPathAccessKind>
    {
        /// <inheritdoc />
        public override PermissionPromptRequestPathAccessKind Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, PermissionPromptRequestPathAccessKind value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(PermissionPromptRequestPathAccessKind));
        }
    }
}

/// <summary>Elicitation mode; "form" for structured input, "url" for browser-based. Defaults to "form" when absent.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct ElicitationRequestedMode : IEquatable<ElicitationRequestedMode>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="ElicitationRequestedMode"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="ElicitationRequestedMode"/>.</param>
    [JsonConstructor]
    public ElicitationRequestedMode(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="ElicitationRequestedMode"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Structured form-based elicitation.</summary>
    public static ElicitationRequestedMode Form { get; } = new("form");

    /// <summary>Browser URL-based elicitation.</summary>
    public static ElicitationRequestedMode Url { get; } = new("url");

    /// <summary>Returns a value indicating whether two <see cref="ElicitationRequestedMode"/> instances are equivalent.</summary>
    public static bool operator ==(ElicitationRequestedMode left, ElicitationRequestedMode right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="ElicitationRequestedMode"/> instances are not equivalent.</summary>
    public static bool operator !=(ElicitationRequestedMode left, ElicitationRequestedMode right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is ElicitationRequestedMode other && Equals(other);

    /// <inheritdoc />
    public bool Equals(ElicitationRequestedMode other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{ElicitationRequestedMode}"/> for serializing <see cref="ElicitationRequestedMode"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<ElicitationRequestedMode>
    {
        /// <inheritdoc />
        public override ElicitationRequestedMode Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, ElicitationRequestedMode value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(ElicitationRequestedMode));
        }
    }
}

/// <summary>The user action: "accept" (submitted form), "decline" (explicitly refused), or "cancel" (dismissed).</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct ElicitationCompletedAction : IEquatable<ElicitationCompletedAction>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="ElicitationCompletedAction"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="ElicitationCompletedAction"/>.</param>
    [JsonConstructor]
    public ElicitationCompletedAction(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="ElicitationCompletedAction"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The user submitted the requested form.</summary>
    public static ElicitationCompletedAction Accept { get; } = new("accept");

    /// <summary>The user explicitly declined the request.</summary>
    public static ElicitationCompletedAction Decline { get; } = new("decline");

    /// <summary>The user dismissed the request.</summary>
    public static ElicitationCompletedAction Cancel { get; } = new("cancel");

    /// <summary>Returns a value indicating whether two <see cref="ElicitationCompletedAction"/> instances are equivalent.</summary>
    public static bool operator ==(ElicitationCompletedAction left, ElicitationCompletedAction right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="ElicitationCompletedAction"/> instances are not equivalent.</summary>
    public static bool operator !=(ElicitationCompletedAction left, ElicitationCompletedAction right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is ElicitationCompletedAction other && Equals(other);

    /// <inheritdoc />
    public bool Equals(ElicitationCompletedAction other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{ElicitationCompletedAction}"/> for serializing <see cref="ElicitationCompletedAction"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<ElicitationCompletedAction>
    {
        /// <inheritdoc />
        public override ElicitationCompletedAction Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, ElicitationCompletedAction value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(ElicitationCompletedAction));
        }
    }
}

/// <summary>Reason the runtime is requesting host-provided MCP OAuth credentials.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct McpOauthRequestReason : IEquatable<McpOauthRequestReason>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="McpOauthRequestReason"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="McpOauthRequestReason"/>.</param>
    [JsonConstructor]
    public McpOauthRequestReason(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="McpOauthRequestReason"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Initial credentials are required before connecting to the MCP server.</summary>
    public static McpOauthRequestReason Initial { get; } = new("initial");

    /// <summary>The current host-provided credential was rejected and a replacement is requested.</summary>
    public static McpOauthRequestReason Refresh { get; } = new("refresh");

    /// <summary>The server requires a new host authorization flow before continuing.</summary>
    public static McpOauthRequestReason Reauth { get; } = new("reauth");

    /// <summary>The server requires a credential with additional scope or audience.</summary>
    public static McpOauthRequestReason Upscope { get; } = new("upscope");

    /// <summary>Returns a value indicating whether two <see cref="McpOauthRequestReason"/> instances are equivalent.</summary>
    public static bool operator ==(McpOauthRequestReason left, McpOauthRequestReason right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="McpOauthRequestReason"/> instances are not equivalent.</summary>
    public static bool operator !=(McpOauthRequestReason left, McpOauthRequestReason right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is McpOauthRequestReason other && Equals(other);

    /// <inheritdoc />
    public bool Equals(McpOauthRequestReason other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{McpOauthRequestReason}"/> for serializing <see cref="McpOauthRequestReason"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<McpOauthRequestReason>
    {
        /// <inheritdoc />
        public override McpOauthRequestReason Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, McpOauthRequestReason value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(McpOauthRequestReason));
        }
    }
}

/// <summary>How the pending MCP OAuth request was completed.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct McpOauthCompletionOutcome : IEquatable<McpOauthCompletionOutcome>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="McpOauthCompletionOutcome"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="McpOauthCompletionOutcome"/>.</param>
    [JsonConstructor]
    public McpOauthCompletionOutcome(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="McpOauthCompletionOutcome"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The request completed with a token-backed OAuth provider.</summary>
    public static McpOauthCompletionOutcome Token { get; } = new("token");

    /// <summary>The request completed without an OAuth provider.</summary>
    public static McpOauthCompletionOutcome Cancelled { get; } = new("cancelled");

    /// <summary>Returns a value indicating whether two <see cref="McpOauthCompletionOutcome"/> instances are equivalent.</summary>
    public static bool operator ==(McpOauthCompletionOutcome left, McpOauthCompletionOutcome right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="McpOauthCompletionOutcome"/> instances are not equivalent.</summary>
    public static bool operator !=(McpOauthCompletionOutcome left, McpOauthCompletionOutcome right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is McpOauthCompletionOutcome other && Equals(other);

    /// <inheritdoc />
    public bool Equals(McpOauthCompletionOutcome other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{McpOauthCompletionOutcome}"/> for serializing <see cref="McpOauthCompletionOutcome"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<McpOauthCompletionOutcome>
    {
        /// <inheritdoc />
        public override McpOauthCompletionOutcome Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, McpOauthCompletionOutcome value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(McpOauthCompletionOutcome));
        }
    }
}

/// <summary>Why dynamic headers are being requested.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct McpHeadersRefreshRequiredReason : IEquatable<McpHeadersRefreshRequiredReason>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="McpHeadersRefreshRequiredReason"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="McpHeadersRefreshRequiredReason"/>.</param>
    [JsonConstructor]
    public McpHeadersRefreshRequiredReason(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="McpHeadersRefreshRequiredReason"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The transport is making its first dynamic header request for this server.</summary>
    public static McpHeadersRefreshRequiredReason Startup { get; } = new("startup");

    /// <summary>The previously cached dynamic headers expired.</summary>
    public static McpHeadersRefreshRequiredReason TtlExpired { get; } = new("ttl-expired");

    /// <summary>The server returned 401 and stale dynamic headers were invalidated.</summary>
    public static McpHeadersRefreshRequiredReason AuthFailed { get; } = new("auth-failed");

    /// <summary>Returns a value indicating whether two <see cref="McpHeadersRefreshRequiredReason"/> instances are equivalent.</summary>
    public static bool operator ==(McpHeadersRefreshRequiredReason left, McpHeadersRefreshRequiredReason right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="McpHeadersRefreshRequiredReason"/> instances are not equivalent.</summary>
    public static bool operator !=(McpHeadersRefreshRequiredReason left, McpHeadersRefreshRequiredReason right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is McpHeadersRefreshRequiredReason other && Equals(other);

    /// <inheritdoc />
    public bool Equals(McpHeadersRefreshRequiredReason other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{McpHeadersRefreshRequiredReason}"/> for serializing <see cref="McpHeadersRefreshRequiredReason"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<McpHeadersRefreshRequiredReason>
    {
        /// <inheritdoc />
        public override McpHeadersRefreshRequiredReason Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, McpHeadersRefreshRequiredReason value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(McpHeadersRefreshRequiredReason));
        }
    }
}

/// <summary>How the pending MCP headers refresh request resolved.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct McpHeadersRefreshCompletedOutcome : IEquatable<McpHeadersRefreshCompletedOutcome>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="McpHeadersRefreshCompletedOutcome"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="McpHeadersRefreshCompletedOutcome"/>.</param>
    [JsonConstructor]
    public McpHeadersRefreshCompletedOutcome(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="McpHeadersRefreshCompletedOutcome"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The host supplied dynamic headers.</summary>
    public static McpHeadersRefreshCompletedOutcome Headers { get; } = new("headers");

    /// <summary>The host responded with no dynamic headers.</summary>
    public static McpHeadersRefreshCompletedOutcome None { get; } = new("none");

    /// <summary>No response arrived within the bounded window.</summary>
    public static McpHeadersRefreshCompletedOutcome Timeout { get; } = new("timeout");

    /// <summary>Returns a value indicating whether two <see cref="McpHeadersRefreshCompletedOutcome"/> instances are equivalent.</summary>
    public static bool operator ==(McpHeadersRefreshCompletedOutcome left, McpHeadersRefreshCompletedOutcome right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="McpHeadersRefreshCompletedOutcome"/> instances are not equivalent.</summary>
    public static bool operator !=(McpHeadersRefreshCompletedOutcome left, McpHeadersRefreshCompletedOutcome right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is McpHeadersRefreshCompletedOutcome other && Equals(other);

    /// <inheritdoc />
    public bool Equals(McpHeadersRefreshCompletedOutcome other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{McpHeadersRefreshCompletedOutcome}"/> for serializing <see cref="McpHeadersRefreshCompletedOutcome"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<McpHeadersRefreshCompletedOutcome>
    {
        /// <inheritdoc />
        public override McpHeadersRefreshCompletedOutcome Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, McpHeadersRefreshCompletedOutcome value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(McpHeadersRefreshCompletedOutcome));
        }
    }
}

/// <summary>Lifecycle phase for a Rust-owned ephemeral query stream.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct UIEphemeralQueryPhase : IEquatable<UIEphemeralQueryPhase>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="UIEphemeralQueryPhase"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="UIEphemeralQueryPhase"/>.</param>
    [JsonConstructor]
    public UIEphemeralQueryPhase(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="UIEphemeralQueryPhase"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The ephemeral query stream has begun.</summary>
    public static UIEphemeralQueryPhase Started { get; } = new("started");

    /// <summary>A partial result chunk was produced by the stream.</summary>
    public static UIEphemeralQueryPhase Chunk { get; } = new("chunk");

    /// <summary>The ephemeral query stream finished successfully.</summary>
    public static UIEphemeralQueryPhase Completed { get; } = new("completed");

    /// <summary>The ephemeral query stream ended with an error.</summary>
    public static UIEphemeralQueryPhase Failed { get; } = new("failed");

    /// <summary>The ephemeral query stream was cancelled before completing.</summary>
    public static UIEphemeralQueryPhase Aborted { get; } = new("aborted");

    /// <summary>Returns a value indicating whether two <see cref="UIEphemeralQueryPhase"/> instances are equivalent.</summary>
    public static bool operator ==(UIEphemeralQueryPhase left, UIEphemeralQueryPhase right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="UIEphemeralQueryPhase"/> instances are not equivalent.</summary>
    public static bool operator !=(UIEphemeralQueryPhase left, UIEphemeralQueryPhase right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is UIEphemeralQueryPhase other && Equals(other);

    /// <inheritdoc />
    public bool Equals(UIEphemeralQueryPhase other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{UIEphemeralQueryPhase}"/> for serializing <see cref="UIEphemeralQueryPhase"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<UIEphemeralQueryPhase>
    {
        /// <inheritdoc />
        public override UIEphemeralQueryPhase Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, UIEphemeralQueryPhase value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(UIEphemeralQueryPhase));
        }
    }
}

/// <summary>The user's auto-mode-switch choice.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct AutoModeSwitchResponse : IEquatable<AutoModeSwitchResponse>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="AutoModeSwitchResponse"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="AutoModeSwitchResponse"/>.</param>
    [JsonConstructor]
    public AutoModeSwitchResponse(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="AutoModeSwitchResponse"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Switch models for this request.</summary>
    public static AutoModeSwitchResponse Yes { get; } = new("yes");

    /// <summary>Switch models now and keep using the replacement automatically.</summary>
    public static AutoModeSwitchResponse YesAlways { get; } = new("yes_always");

    /// <summary>Do not switch models.</summary>
    public static AutoModeSwitchResponse No { get; } = new("no");

    /// <summary>Returns a value indicating whether two <see cref="AutoModeSwitchResponse"/> instances are equivalent.</summary>
    public static bool operator ==(AutoModeSwitchResponse left, AutoModeSwitchResponse right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="AutoModeSwitchResponse"/> instances are not equivalent.</summary>
    public static bool operator !=(AutoModeSwitchResponse left, AutoModeSwitchResponse right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is AutoModeSwitchResponse other && Equals(other);

    /// <inheritdoc />
    public bool Equals(AutoModeSwitchResponse other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{AutoModeSwitchResponse}"/> for serializing <see cref="AutoModeSwitchResponse"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<AutoModeSwitchResponse>
    {
        /// <inheritdoc />
        public override AutoModeSwitchResponse Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, AutoModeSwitchResponse value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(AutoModeSwitchResponse));
        }
    }
}

/// <summary>User action selected for an exhausted session limit.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct SessionLimitsExhaustedResponseAction : IEquatable<SessionLimitsExhaustedResponseAction>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="SessionLimitsExhaustedResponseAction"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="SessionLimitsExhaustedResponseAction"/>.</param>
    [JsonConstructor]
    public SessionLimitsExhaustedResponseAction(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="SessionLimitsExhaustedResponseAction"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Increase the current max by an exact AI Credits amount.</summary>
    public static SessionLimitsExhaustedResponseAction Add { get; } = new("add");

    /// <summary>Set a new absolute max AI Credits value.</summary>
    public static SessionLimitsExhaustedResponseAction Set { get; } = new("set");

    /// <summary>Remove the current session limit.</summary>
    public static SessionLimitsExhaustedResponseAction Unset { get; } = new("unset");

    /// <summary>Leave the limit unchanged and cancel the blocked model request.</summary>
    public static SessionLimitsExhaustedResponseAction Cancel { get; } = new("cancel");

    /// <summary>Returns a value indicating whether two <see cref="SessionLimitsExhaustedResponseAction"/> instances are equivalent.</summary>
    public static bool operator ==(SessionLimitsExhaustedResponseAction left, SessionLimitsExhaustedResponseAction right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="SessionLimitsExhaustedResponseAction"/> instances are not equivalent.</summary>
    public static bool operator !=(SessionLimitsExhaustedResponseAction left, SessionLimitsExhaustedResponseAction right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is SessionLimitsExhaustedResponseAction other && Equals(other);

    /// <inheritdoc />
    public bool Equals(SessionLimitsExhaustedResponseAction other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{SessionLimitsExhaustedResponseAction}"/> for serializing <see cref="SessionLimitsExhaustedResponseAction"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<SessionLimitsExhaustedResponseAction>
    {
        /// <inheritdoc />
        public override SessionLimitsExhaustedResponseAction Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, SessionLimitsExhaustedResponseAction value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(SessionLimitsExhaustedResponseAction));
        }
    }
}

/// <summary>Coarse request-difficulty bucket for UX explainability.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct AutoModeResolvedReasoningBucket : IEquatable<AutoModeResolvedReasoningBucket>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="AutoModeResolvedReasoningBucket"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="AutoModeResolvedReasoningBucket"/>.</param>
    [JsonConstructor]
    public AutoModeResolvedReasoningBucket(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="AutoModeResolvedReasoningBucket"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The request looks low-reasoning; a lighter model is appropriate.</summary>
    public static AutoModeResolvedReasoningBucket Low { get; } = new("low");

    /// <summary>The request needs a moderate amount of reasoning.</summary>
    public static AutoModeResolvedReasoningBucket Medium { get; } = new("medium");

    /// <summary>The request looks high-reasoning; a stronger model is appropriate.</summary>
    public static AutoModeResolvedReasoningBucket High { get; } = new("high");

    /// <summary>Returns a value indicating whether two <see cref="AutoModeResolvedReasoningBucket"/> instances are equivalent.</summary>
    public static bool operator ==(AutoModeResolvedReasoningBucket left, AutoModeResolvedReasoningBucket right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="AutoModeResolvedReasoningBucket"/> instances are not equivalent.</summary>
    public static bool operator !=(AutoModeResolvedReasoningBucket left, AutoModeResolvedReasoningBucket right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is AutoModeResolvedReasoningBucket other && Equals(other);

    /// <inheritdoc />
    public bool Equals(AutoModeResolvedReasoningBucket other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{AutoModeResolvedReasoningBucket}"/> for serializing <see cref="AutoModeResolvedReasoningBucket"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<AutoModeResolvedReasoningBucket>
    {
        /// <inheritdoc />
        public override AutoModeResolvedReasoningBucket Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, AutoModeResolvedReasoningBucket value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(AutoModeResolvedReasoningBucket));
        }
    }
}

/// <summary>Summary of which managed-settings channels contributed to the effective session policy. Use the per-channel booleans for exact provenance.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct ManagedSettingsResolvedSource : IEquatable<ManagedSettingsResolvedSource>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="ManagedSettingsResolvedSource"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="ManagedSettingsResolvedSource"/>.</param>
    [JsonConstructor]
    public ManagedSettingsResolvedSource(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="ManagedSettingsResolvedSource"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Only the server/account channel contributed.</summary>
    public static ManagedSettingsResolvedSource Server { get; } = new("server");

    /// <summary>Only the device MDM/plist/registry/file channel contributed.</summary>
    public static ManagedSettingsResolvedSource Device { get; } = new("device");

    /// <summary>Only session-local SDK-host injection contributed.</summary>
    public static ManagedSettingsResolvedSource Client { get; } = new("client");

    /// <summary>A policy helper registered by device or server policy contributed. Device registration takes priority when present.</summary>
    public static ManagedSettingsResolvedSource PolicyHelper { get; } = new("policyHelper");

    /// <summary>More than one channel contributed. Ordinary keys resolve device over server over policy helper per key, while permissions compose restrictively across all present layers.</summary>
    public static ManagedSettingsResolvedSource Mixed { get; } = new("mixed");

    /// <summary>No managed policy is in force (no channel contributed).</summary>
    public static ManagedSettingsResolvedSource None { get; } = new("none");

    /// <summary>Returns a value indicating whether two <see cref="ManagedSettingsResolvedSource"/> instances are equivalent.</summary>
    public static bool operator ==(ManagedSettingsResolvedSource left, ManagedSettingsResolvedSource right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="ManagedSettingsResolvedSource"/> instances are not equivalent.</summary>
    public static bool operator !=(ManagedSettingsResolvedSource left, ManagedSettingsResolvedSource right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is ManagedSettingsResolvedSource other && Equals(other);

    /// <inheritdoc />
    public bool Equals(ManagedSettingsResolvedSource other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{ManagedSettingsResolvedSource}"/> for serializing <see cref="ManagedSettingsResolvedSource"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<ManagedSettingsResolvedSource>
    {
        /// <inheritdoc />
        public override ManagedSettingsResolvedSource Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, ManagedSettingsResolvedSource value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(ManagedSettingsResolvedSource));
        }
    }
}

/// <summary>The category of runtime action that enterprise managed settings governed (blocked or capped).</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct ManagedSettingsEnforcedAction : IEquatable<ManagedSettingsEnforcedAction>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="ManagedSettingsEnforcedAction"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="ManagedSettingsEnforcedAction"/>.</param>
    [JsonConstructor]
    public ManagedSettingsEnforcedAction(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="ManagedSettingsEnforcedAction"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>An attempt to turn on a bypass-permissions ("yolo") escalation was refused or capped because policy disables bypass-permissions mode.</summary>
    public static ManagedSettingsEnforcedAction BypassPermissionsBlocked { get; } = new("bypass_permissions_blocked");

    /// <summary>Returns a value indicating whether two <see cref="ManagedSettingsEnforcedAction"/> instances are equivalent.</summary>
    public static bool operator ==(ManagedSettingsEnforcedAction left, ManagedSettingsEnforcedAction right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="ManagedSettingsEnforcedAction"/> instances are not equivalent.</summary>
    public static bool operator !=(ManagedSettingsEnforcedAction left, ManagedSettingsEnforcedAction right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is ManagedSettingsEnforcedAction other && Equals(other);

    /// <inheritdoc />
    public bool Equals(ManagedSettingsEnforcedAction other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{ManagedSettingsEnforcedAction}"/> for serializing <see cref="ManagedSettingsEnforcedAction"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<ManagedSettingsEnforcedAction>
    {
        /// <inheritdoc />
        public override ManagedSettingsEnforcedAction Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, ManagedSettingsEnforcedAction value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(ManagedSettingsEnforcedAction));
        }
    }
}

/// <summary>For a `bypass_permissions_blocked` action, which permission-escalation primitive was refused.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct ManagedSettingsEnforcedEscalation : IEquatable<ManagedSettingsEnforcedEscalation>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="ManagedSettingsEnforcedEscalation"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="ManagedSettingsEnforcedEscalation"/>.</param>
    [JsonConstructor]
    public ManagedSettingsEnforcedEscalation(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="ManagedSettingsEnforcedEscalation"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Full allow-all permissions — automatically approving tools, paths, and URLs.</summary>
    public static ManagedSettingsEnforcedEscalation AllowAll { get; } = new("allow_all");

    /// <summary>Automatic approval of all tool permission requests.</summary>
    public static ManagedSettingsEnforcedEscalation ApproveAll { get; } = new("approve_all");

    /// <summary>Assisted mode — keeps normal prompt paths and adds an LLM recommendation, distinct from allow-all.</summary>
    public static ManagedSettingsEnforcedEscalation AssistedApproval { get; } = new("assisted_approval");

    /// <summary>Unrestricted filesystem access outside the session's allowed directories.</summary>
    public static ManagedSettingsEnforcedEscalation UnrestrictedPaths { get; } = new("unrestricted_paths");

    /// <summary>Unrestricted URL fetch access.</summary>
    public static ManagedSettingsEnforcedEscalation UnrestrictedUrls { get; } = new("unrestricted_urls");

    /// <summary>A server-wide MCP "Always Allow" (or `--allow-tool &lt;server&gt;`) blanket that would auto-approve every tool from an MCP server. Capped to per-tool approval; each tool still prompts.</summary>
    public static ManagedSettingsEnforcedEscalation ServerWideMcpApproval { get; } = new("server_wide_mcp_approval");

    /// <summary>Returns a value indicating whether two <see cref="ManagedSettingsEnforcedEscalation"/> instances are equivalent.</summary>
    public static bool operator ==(ManagedSettingsEnforcedEscalation left, ManagedSettingsEnforcedEscalation right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="ManagedSettingsEnforcedEscalation"/> instances are not equivalent.</summary>
    public static bool operator !=(ManagedSettingsEnforcedEscalation left, ManagedSettingsEnforcedEscalation right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is ManagedSettingsEnforcedEscalation other && Equals(other);

    /// <inheritdoc />
    public bool Equals(ManagedSettingsEnforcedEscalation other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{ManagedSettingsEnforcedEscalation}"/> for serializing <see cref="ManagedSettingsEnforcedEscalation"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<ManagedSettingsEnforcedEscalation>
    {
        /// <inheritdoc />
        public override ManagedSettingsEnforcedEscalation Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, ManagedSettingsEnforcedEscalation value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(ManagedSettingsEnforcedEscalation));
        }
    }
}

/// <summary>Exit plan mode action.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct ExitPlanModeAction : IEquatable<ExitPlanModeAction>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="ExitPlanModeAction"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="ExitPlanModeAction"/>.</param>
    [JsonConstructor]
    public ExitPlanModeAction(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="ExitPlanModeAction"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Exit plan mode without starting implementation.</summary>
    public static ExitPlanModeAction ExitOnly { get; } = new("exit_only");

    /// <summary>Exit plan mode and continue in interactive mode.</summary>
    public static ExitPlanModeAction Interactive { get; } = new("interactive");

    /// <summary>Exit plan mode and continue autonomously.</summary>
    public static ExitPlanModeAction Autopilot { get; } = new("autopilot");

    /// <summary>Exit plan mode and continue with parallel autonomous workers.</summary>
    public static ExitPlanModeAction AutopilotFleet { get; } = new("autopilot_fleet");

    /// <summary>Returns a value indicating whether two <see cref="ExitPlanModeAction"/> instances are equivalent.</summary>
    public static bool operator ==(ExitPlanModeAction left, ExitPlanModeAction right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="ExitPlanModeAction"/> instances are not equivalent.</summary>
    public static bool operator !=(ExitPlanModeAction left, ExitPlanModeAction right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is ExitPlanModeAction other && Equals(other);

    /// <inheritdoc />
    public bool Equals(ExitPlanModeAction other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{ExitPlanModeAction}"/> for serializing <see cref="ExitPlanModeAction"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<ExitPlanModeAction>
    {
        /// <inheritdoc />
        public override ExitPlanModeAction Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, ExitPlanModeAction value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(ExitPlanModeAction));
        }
    }
}

/// <summary>Terminal status a factory run committed. A settled run is never `pending` or `running`, so those two members of the run-status domain are deliberately absent.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct FactoryRunSettledStatus : IEquatable<FactoryRunSettledStatus>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="FactoryRunSettledStatus"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="FactoryRunSettledStatus"/>.</param>
    [JsonConstructor]
    public FactoryRunSettledStatus(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="FactoryRunSettledStatus"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The factory body resolved and its result was committed.</summary>
    public static FactoryRunSettledStatus Completed { get; } = new("completed");

    /// <summary>The run was stopped by a limit, an approval refusal or another policy decision.</summary>
    public static FactoryRunSettledStatus Halted { get; } = new("halted");

    /// <summary>The run was cancelled by its caller or by session disposal.</summary>
    public static FactoryRunSettledStatus Cancelled { get; } = new("cancelled");

    /// <summary>The run failed, with `failureType` carrying the class when it has one.</summary>
    public static FactoryRunSettledStatus Error { get; } = new("error");

    /// <summary>Returns a value indicating whether two <see cref="FactoryRunSettledStatus"/> instances are equivalent.</summary>
    public static bool operator ==(FactoryRunSettledStatus left, FactoryRunSettledStatus right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="FactoryRunSettledStatus"/> instances are not equivalent.</summary>
    public static bool operator !=(FactoryRunSettledStatus left, FactoryRunSettledStatus right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is FactoryRunSettledStatus other && Equals(other);

    /// <inheritdoc />
    public bool Equals(FactoryRunSettledStatus other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{FactoryRunSettledStatus}"/> for serializing <see cref="FactoryRunSettledStatus"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<FactoryRunSettledStatus>
    {
        /// <inheritdoc />
        public override FactoryRunSettledStatus Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, FactoryRunSettledStatus value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(FactoryRunSettledStatus));
        }
    }
}

/// <summary>Source location type (e.g., project, personal-copilot, plugin, builtin, sdk).</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct SkillSource : IEquatable<SkillSource>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="SkillSource"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="SkillSource"/>.</param>
    [JsonConstructor]
    public SkillSource(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="SkillSource"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Skill defined in the current project's skill directories.</summary>
    public static SkillSource Project { get; } = new("project");

    /// <summary>Skill discovered from a parent directory in the current workspace tree.</summary>
    public static SkillSource Inherited { get; } = new("inherited");

    /// <summary>Skill defined in the user's Copilot skill directory.</summary>
    public static SkillSource PersonalCopilot { get; } = new("personal-copilot");

    /// <summary>Skill defined in the user's personal agents skill directory.</summary>
    public static SkillSource PersonalAgents { get; } = new("personal-agents");

    /// <summary>Skill provided by an installed plugin.</summary>
    public static SkillSource Plugin { get; } = new("plugin");

    /// <summary>Skill loaded from a configured custom skill directory.</summary>
    public static SkillSource Custom { get; } = new("custom");

    /// <summary>Skill bundled with the runtime.</summary>
    public static SkillSource Builtin { get; } = new("builtin");

    /// <summary>Pathless skill supplied lazily by an SDK skill provider.</summary>
    public static SkillSource Sdk { get; } = new("sdk");

    /// <summary>Returns a value indicating whether two <see cref="SkillSource"/> instances are equivalent.</summary>
    public static bool operator ==(SkillSource left, SkillSource right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="SkillSource"/> instances are not equivalent.</summary>
    public static bool operator !=(SkillSource left, SkillSource right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is SkillSource other && Equals(other);

    /// <inheritdoc />
    public bool Equals(SkillSource other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{SkillSource}"/> for serializing <see cref="SkillSource"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<SkillSource>
    {
        /// <inheritdoc />
        public override SkillSource Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, SkillSource value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(SkillSource));
        }
    }
}

/// <summary>Whether configured models are advisory preferences or required constraints.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct AgentModelPolicy : IEquatable<AgentModelPolicy>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="AgentModelPolicy"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="AgentModelPolicy"/>.</param>
    [JsonConstructor]
    public AgentModelPolicy(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="AgentModelPolicy"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Treat the authored models as advisory preferences that callers may override.</summary>
    public static AgentModelPolicy Preferred { get; } = new("preferred");

    /// <summary>Require subagent execution to use one of the authored models.</summary>
    public static AgentModelPolicy Required { get; } = new("required");

    /// <summary>Returns a value indicating whether two <see cref="AgentModelPolicy"/> instances are equivalent.</summary>
    public static bool operator ==(AgentModelPolicy left, AgentModelPolicy right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="AgentModelPolicy"/> instances are not equivalent.</summary>
    public static bool operator !=(AgentModelPolicy left, AgentModelPolicy right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is AgentModelPolicy other && Equals(other);

    /// <inheritdoc />
    public bool Equals(AgentModelPolicy other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{AgentModelPolicy}"/> for serializing <see cref="AgentModelPolicy"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<AgentModelPolicy>
    {
        /// <inheritdoc />
        public override AgentModelPolicy Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, AgentModelPolicy value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(AgentModelPolicy));
        }
    }
}

/// <summary>Configuration source: user, workspace, plugin, or builtin.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct McpServerSource : IEquatable<McpServerSource>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="McpServerSource"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="McpServerSource"/>.</param>
    [JsonConstructor]
    public McpServerSource(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="McpServerSource"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Server configured in the user's global MCP configuration.</summary>
    public static McpServerSource User { get; } = new("user");

    /// <summary>Server configured by the current workspace.</summary>
    public static McpServerSource Workspace { get; } = new("workspace");

    /// <summary>Server contributed by an installed plugin.</summary>
    public static McpServerSource Plugin { get; } = new("plugin");

    /// <summary>Server bundled with the runtime.</summary>
    public static McpServerSource Builtin { get; } = new("builtin");

    /// <summary>Returns a value indicating whether two <see cref="McpServerSource"/> instances are equivalent.</summary>
    public static bool operator ==(McpServerSource left, McpServerSource right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="McpServerSource"/> instances are not equivalent.</summary>
    public static bool operator !=(McpServerSource left, McpServerSource right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is McpServerSource other && Equals(other);

    /// <inheritdoc />
    public bool Equals(McpServerSource other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{McpServerSource}"/> for serializing <see cref="McpServerSource"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<McpServerSource>
    {
        /// <inheritdoc />
        public override McpServerSource Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, McpServerSource value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(McpServerSource));
        }
    }
}

/// <summary>Connection status: connected, failed, needs-auth, pending, disabled, stopped, or not_configured.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct McpServerStatus : IEquatable<McpServerStatus>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="McpServerStatus"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="McpServerStatus"/>.</param>
    [JsonConstructor]
    public McpServerStatus(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="McpServerStatus"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The server is connected and available.</summary>
    public static McpServerStatus Connected { get; } = new("connected");

    /// <summary>The server failed to connect or initialize.</summary>
    public static McpServerStatus Failed { get; } = new("failed");

    /// <summary>The server requires authentication before it can connect.</summary>
    public static McpServerStatus NeedsAuth { get; } = new("needs-auth");

    /// <summary>The server connection is still being established.</summary>
    public static McpServerStatus Pending { get; } = new("pending");

    /// <summary>The server is configured but disabled.</summary>
    public static McpServerStatus Disabled { get; } = new("disabled");

    /// <summary>The server was intentionally stopped and can be restarted on demand when policy permits; a server quarantined by restrictive managed policy stays stopped and cannot be restarted until the policy allows it.</summary>
    public static McpServerStatus Stopped { get; } = new("stopped");

    /// <summary>The server is not configured for this session.</summary>
    public static McpServerStatus NotConfigured { get; } = new("not_configured");

    /// <summary>Returns a value indicating whether two <see cref="McpServerStatus"/> instances are equivalent.</summary>
    public static bool operator ==(McpServerStatus left, McpServerStatus right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="McpServerStatus"/> instances are not equivalent.</summary>
    public static bool operator !=(McpServerStatus left, McpServerStatus right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is McpServerStatus other && Equals(other);

    /// <inheritdoc />
    public bool Equals(McpServerStatus other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{McpServerStatus}"/> for serializing <see cref="McpServerStatus"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<McpServerStatus>
    {
        /// <inheritdoc />
        public override McpServerStatus Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, McpServerStatus value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(McpServerStatus));
        }
    }
}

/// <summary>Transport mechanism: stdio, http, sse (deprecated), or memory (in-process MCP server).</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct McpServerTransport : IEquatable<McpServerTransport>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="McpServerTransport"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="McpServerTransport"/>.</param>
    [JsonConstructor]
    public McpServerTransport(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="McpServerTransport"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Server communicates over stdio with a local child process.</summary>
    public static McpServerTransport Stdio { get; } = new("stdio");

    /// <summary>Server communicates over streamable HTTP.</summary>
    public static McpServerTransport Http { get; } = new("http");

    /// <summary>Server communicates over Server-Sent Events (deprecated).</summary>
    public static McpServerTransport Sse { get; } = new("sse");

    /// <summary>Server is backed by an in-memory runtime implementation.</summary>
    public static McpServerTransport Memory { get; } = new("memory");

    /// <summary>Returns a value indicating whether two <see cref="McpServerTransport"/> instances are equivalent.</summary>
    public static bool operator ==(McpServerTransport left, McpServerTransport right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="McpServerTransport"/> instances are not equivalent.</summary>
    public static bool operator !=(McpServerTransport left, McpServerTransport right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is McpServerTransport other && Equals(other);

    /// <inheritdoc />
    public bool Equals(McpServerTransport other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{McpServerTransport}"/> for serializing <see cref="McpServerTransport"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<McpServerTransport>
    {
        /// <inheritdoc />
        public override McpServerTransport Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, McpServerTransport value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(McpServerTransport));
        }
    }
}

/// <summary>Discovery source.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct ExtensionsLoadedExtensionSource : IEquatable<ExtensionsLoadedExtensionSource>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="ExtensionsLoadedExtensionSource"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="ExtensionsLoadedExtensionSource"/>.</param>
    [JsonConstructor]
    public ExtensionsLoadedExtensionSource(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="ExtensionsLoadedExtensionSource"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Extension discovered from the current project.</summary>
    public static ExtensionsLoadedExtensionSource Project { get; } = new("project");

    /// <summary>Extension discovered from the user's extension directory.</summary>
    public static ExtensionsLoadedExtensionSource User { get; } = new("user");

    /// <summary>Extension contributed by an installed plugin.</summary>
    public static ExtensionsLoadedExtensionSource Plugin { get; } = new("plugin");

    /// <summary>Extension discovered from the current session's state directory.</summary>
    public static ExtensionsLoadedExtensionSource Session { get; } = new("session");

    /// <summary>Returns a value indicating whether two <see cref="ExtensionsLoadedExtensionSource"/> instances are equivalent.</summary>
    public static bool operator ==(ExtensionsLoadedExtensionSource left, ExtensionsLoadedExtensionSource right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="ExtensionsLoadedExtensionSource"/> instances are not equivalent.</summary>
    public static bool operator !=(ExtensionsLoadedExtensionSource left, ExtensionsLoadedExtensionSource right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is ExtensionsLoadedExtensionSource other && Equals(other);

    /// <inheritdoc />
    public bool Equals(ExtensionsLoadedExtensionSource other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{ExtensionsLoadedExtensionSource}"/> for serializing <see cref="ExtensionsLoadedExtensionSource"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<ExtensionsLoadedExtensionSource>
    {
        /// <inheritdoc />
        public override ExtensionsLoadedExtensionSource Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, ExtensionsLoadedExtensionSource value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(ExtensionsLoadedExtensionSource));
        }
    }
}

/// <summary>Current status: running, disabled, failed, or starting.</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct ExtensionsLoadedExtensionStatus : IEquatable<ExtensionsLoadedExtensionStatus>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="ExtensionsLoadedExtensionStatus"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="ExtensionsLoadedExtensionStatus"/>.</param>
    [JsonConstructor]
    public ExtensionsLoadedExtensionStatus(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="ExtensionsLoadedExtensionStatus"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The extension process is running.</summary>
    public static ExtensionsLoadedExtensionStatus Running { get; } = new("running");

    /// <summary>The extension is installed but disabled.</summary>
    public static ExtensionsLoadedExtensionStatus Disabled { get; } = new("disabled");

    /// <summary>The extension failed to start or crashed.</summary>
    public static ExtensionsLoadedExtensionStatus Failed { get; } = new("failed");

    /// <summary>The extension process is starting.</summary>
    public static ExtensionsLoadedExtensionStatus Starting { get; } = new("starting");

    /// <summary>Returns a value indicating whether two <see cref="ExtensionsLoadedExtensionStatus"/> instances are equivalent.</summary>
    public static bool operator ==(ExtensionsLoadedExtensionStatus left, ExtensionsLoadedExtensionStatus right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="ExtensionsLoadedExtensionStatus"/> instances are not equivalent.</summary>
    public static bool operator !=(ExtensionsLoadedExtensionStatus left, ExtensionsLoadedExtensionStatus right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is ExtensionsLoadedExtensionStatus other && Equals(other);

    /// <inheritdoc />
    public bool Equals(ExtensionsLoadedExtensionStatus other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{ExtensionsLoadedExtensionStatus}"/> for serializing <see cref="ExtensionsLoadedExtensionStatus"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<ExtensionsLoadedExtensionStatus>
    {
        /// <inheritdoc />
        public override ExtensionsLoadedExtensionStatus Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, ExtensionsLoadedExtensionStatus value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(ExtensionsLoadedExtensionStatus));
        }
    }
}

[JsonSourceGenerationOptions(
    JsonSerializerDefaults.Web,
    AllowOutOfOrderMetadataProperties = true,
    NumberHandling = JsonNumberHandling.AllowReadingFromString,
    DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull)]
[JsonSerializable(typeof(AbortData))]
[JsonSerializable(typeof(AbortEvent))]
[JsonSerializable(typeof(AgentInterruptedData))]
[JsonSerializable(typeof(AgentInterruptedEvent))]
[JsonSerializable(typeof(AssistantFusionPhaseActivityData))]
[JsonSerializable(typeof(AssistantFusionPhaseActivityEvent))]
[JsonSerializable(typeof(AssistantFusionPhaseCompletedData))]
[JsonSerializable(typeof(AssistantFusionPhaseCompletedEvent))]
[JsonSerializable(typeof(AssistantFusionPhaseFailedData))]
[JsonSerializable(typeof(AssistantFusionPhaseFailedEvent))]
[JsonSerializable(typeof(AssistantFusionPhaseStartedData))]
[JsonSerializable(typeof(AssistantFusionPhaseStartedEvent))]
[JsonSerializable(typeof(AssistantIdleData))]
[JsonSerializable(typeof(AssistantIdleEvent))]
[JsonSerializable(typeof(AssistantIntentData))]
[JsonSerializable(typeof(AssistantIntentEvent))]
[JsonSerializable(typeof(AssistantMessageData))]
[JsonSerializable(typeof(AssistantMessageDeltaData))]
[JsonSerializable(typeof(AssistantMessageDeltaEvent))]
[JsonSerializable(typeof(AssistantMessageEvent))]
[JsonSerializable(typeof(AssistantMessageReasoningBlocks))]
[JsonSerializable(typeof(AssistantMessageServerTools))]
[JsonSerializable(typeof(AssistantMessageStartData))]
[JsonSerializable(typeof(AssistantMessageStartEvent))]
[JsonSerializable(typeof(AssistantMessageToolRequest))]
[JsonSerializable(typeof(AssistantMessageToolRequestCaller))]
[JsonSerializable(typeof(AssistantReasoningData))]
[JsonSerializable(typeof(AssistantReasoningDeltaData))]
[JsonSerializable(typeof(AssistantReasoningDeltaEvent))]
[JsonSerializable(typeof(AssistantReasoningEvent))]
[JsonSerializable(typeof(AssistantServerToolProgressData))]
[JsonSerializable(typeof(AssistantServerToolProgressEvent))]
[JsonSerializable(typeof(AssistantStreamingDeltaData))]
[JsonSerializable(typeof(AssistantStreamingDeltaEvent))]
[JsonSerializable(typeof(AssistantToolCallDeltaData))]
[JsonSerializable(typeof(AssistantToolCallDeltaEvent))]
[JsonSerializable(typeof(AssistantTurnEndData))]
[JsonSerializable(typeof(AssistantTurnEndEvent))]
[JsonSerializable(typeof(AssistantTurnRetryData))]
[JsonSerializable(typeof(AssistantTurnRetryEvent))]
[JsonSerializable(typeof(AssistantTurnStartData))]
[JsonSerializable(typeof(AssistantTurnStartEvent))]
[JsonSerializable(typeof(AssistantUsageCopilotUsage))]
[JsonSerializable(typeof(AssistantUsageCopilotUsageTokenDetail))]
[JsonSerializable(typeof(AssistantUsageData))]
[JsonSerializable(typeof(AssistantUsageEvent))]
[JsonSerializable(typeof(AssistantUsageQuotaSnapshot))]
[JsonSerializable(typeof(Attachment))]
[JsonSerializable(typeof(AttachmentBlob))]
[JsonSerializable(typeof(AttachmentDirectory))]
[JsonSerializable(typeof(AttachmentExtensionContext))]
[JsonSerializable(typeof(AttachmentFile))]
[JsonSerializable(typeof(AttachmentFileLineRange))]
[JsonSerializable(typeof(AttachmentGitHubActionsJob))]
[JsonSerializable(typeof(AttachmentGitHubCommit))]
[JsonSerializable(typeof(AttachmentGitHubFile))]
[JsonSerializable(typeof(AttachmentGitHubFileDiff))]
[JsonSerializable(typeof(AttachmentGitHubFileDiffSide))]
[JsonSerializable(typeof(AttachmentGitHubReference))]
[JsonSerializable(typeof(AttachmentGitHubRelease))]
[JsonSerializable(typeof(AttachmentGitHubRepository))]
[JsonSerializable(typeof(AttachmentGitHubSnippet))]
[JsonSerializable(typeof(AttachmentGitHubTreeComparison))]
[JsonSerializable(typeof(AttachmentGitHubTreeComparisonSide))]
[JsonSerializable(typeof(AttachmentGitHubUrl))]
[JsonSerializable(typeof(AttachmentSelection))]
[JsonSerializable(typeof(AttachmentSelectionDetails))]
[JsonSerializable(typeof(AttachmentSelectionDetailsEnd))]
[JsonSerializable(typeof(AttachmentSelectionDetailsStart))]
[JsonSerializable(typeof(AutoModeSwitchCompletedData))]
[JsonSerializable(typeof(AutoModeSwitchCompletedEvent))]
[JsonSerializable(typeof(AutoModeSwitchRequestedData))]
[JsonSerializable(typeof(AutoModeSwitchRequestedEvent))]
[JsonSerializable(typeof(BinaryAssetReference))]
[JsonSerializable(typeof(CanvasRegistryChangedCanvas))]
[JsonSerializable(typeof(CanvasRegistryChangedCanvasAction))]
[JsonSerializable(typeof(CapabilitiesChangedData))]
[JsonSerializable(typeof(CapabilitiesChangedEvent))]
[JsonSerializable(typeof(CapabilitiesChangedUI))]
[JsonSerializable(typeof(CitableSource))]
[JsonSerializable(typeof(CitationLocation))]
[JsonSerializable(typeof(CitationLocationBlock))]
[JsonSerializable(typeof(CitationLocationChar))]
[JsonSerializable(typeof(CitationLocationPage))]
[JsonSerializable(typeof(CitationReference))]
[JsonSerializable(typeof(CitationSource))]
[JsonSerializable(typeof(CitationSpan))]
[JsonSerializable(typeof(Citations))]
[JsonSerializable(typeof(CommandCompletedData))]
[JsonSerializable(typeof(CommandCompletedEvent))]
[JsonSerializable(typeof(CommandExecuteData))]
[JsonSerializable(typeof(CommandExecuteEvent))]
[JsonSerializable(typeof(CommandQueuedData))]
[JsonSerializable(typeof(CommandQueuedEvent))]
[JsonSerializable(typeof(CommandsChangedCommand))]
[JsonSerializable(typeof(CommandsChangedData))]
[JsonSerializable(typeof(CommandsChangedEvent))]
[JsonSerializable(typeof(CompactionCompleteCompactionTokensUsed))]
[JsonSerializable(typeof(CompactionCompleteCompactionTokensUsedCopilotUsage))]
[JsonSerializable(typeof(CompactionCompleteCompactionTokensUsedCopilotUsageTokenDetail))]
[JsonSerializable(typeof(CompletionReceiptEventRange))]
[JsonSerializable(typeof(CompletionReceiptFinalTool))]
[JsonSerializable(typeof(CustomAgentsUpdatedAgent))]
[JsonSerializable(typeof(ElicitationCompletedData))]
[JsonSerializable(typeof(ElicitationCompletedEvent))]
[JsonSerializable(typeof(ElicitationRequestedData))]
[JsonSerializable(typeof(ElicitationRequestedEvent))]
[JsonSerializable(typeof(ElicitationRequestedSchema))]
[JsonSerializable(typeof(EmbeddedBlobResourceContents))]
[JsonSerializable(typeof(EmbeddedTextResourceContents))]
[JsonSerializable(typeof(ExitPlanModeCompletedData))]
[JsonSerializable(typeof(ExitPlanModeCompletedEvent))]
[JsonSerializable(typeof(ExitPlanModeRequestedData))]
[JsonSerializable(typeof(ExitPlanModeRequestedEvent))]
[JsonSerializable(typeof(ExtensionsLoadedExtension))]
[JsonSerializable(typeof(ExternalToolCompletedData))]
[JsonSerializable(typeof(ExternalToolCompletedEvent))]
[JsonSerializable(typeof(ExternalToolRequestedData))]
[JsonSerializable(typeof(ExternalToolRequestedEvent))]
[JsonSerializable(typeof(FactoryPermissionPhase))]
[JsonSerializable(typeof(FactoryRunSettledData))]
[JsonSerializable(typeof(FactoryRunSettledEvent))]
[JsonSerializable(typeof(FactoryRunStartedData))]
[JsonSerializable(typeof(FactoryRunStartedEvent))]
[JsonSerializable(typeof(FactoryRunUpdatedData))]
[JsonSerializable(typeof(FactoryRunUpdatedEvent))]
[JsonSerializable(typeof(FusionAttribution))]
[JsonSerializable(typeof(FusionFollowUpRecommendation))]
[JsonSerializable(typeof(FusionPhasePlanStep))]
[JsonSerializable(typeof(FusionPhaseUsage))]
[JsonSerializable(typeof(FusionScores))]
[JsonSerializable(typeof(FusionStagedTerminal))]
[JsonSerializable(typeof(GitHubMcpToolConfig))]
[JsonSerializable(typeof(GitHubRepoRef))]
[JsonSerializable(typeof(HandoffRepository))]
[JsonSerializable(typeof(HeaderEntry))]
[JsonSerializable(typeof(HookEndData))]
[JsonSerializable(typeof(HookEndError))]
[JsonSerializable(typeof(HookEndEvent))]
[JsonSerializable(typeof(HookProgressData))]
[JsonSerializable(typeof(HookProgressEvent))]
[JsonSerializable(typeof(HookStartData))]
[JsonSerializable(typeof(HookStartEvent))]
[JsonSerializable(typeof(McpAppToolCallCompleteData))]
[JsonSerializable(typeof(McpAppToolCallCompleteError))]
[JsonSerializable(typeof(McpAppToolCallCompleteEvent))]
[JsonSerializable(typeof(McpAppToolCallCompleteToolMeta))]
[JsonSerializable(typeof(McpAppToolCallCompleteToolMetaUI))]
[JsonSerializable(typeof(McpHeadersRefreshCompletedData))]
[JsonSerializable(typeof(McpHeadersRefreshCompletedEvent))]
[JsonSerializable(typeof(McpHeadersRefreshRequiredData))]
[JsonSerializable(typeof(McpHeadersRefreshRequiredEvent))]
[JsonSerializable(typeof(McpOauthCompletedData))]
[JsonSerializable(typeof(McpOauthCompletedEvent))]
[JsonSerializable(typeof(McpOauthHttpResponse))]
[JsonSerializable(typeof(McpOauthRequiredData))]
[JsonSerializable(typeof(McpOauthRequiredEvent))]
[JsonSerializable(typeof(McpOauthRequiredStaticClientConfig))]
[JsonSerializable(typeof(McpOauthWWWAuthenticateParams))]
[JsonSerializable(typeof(McpPromptsListChangedData))]
[JsonSerializable(typeof(McpPromptsListChangedEvent))]
[JsonSerializable(typeof(McpResourcesListChangedData))]
[JsonSerializable(typeof(McpResourcesListChangedEvent))]
[JsonSerializable(typeof(McpServerMetadata))]
[JsonSerializable(typeof(McpServersLoadedServer))]
[JsonSerializable(typeof(McpToolsListChangedData))]
[JsonSerializable(typeof(McpToolsListChangedEvent))]
[JsonSerializable(typeof(ModelCallFailureData))]
[JsonSerializable(typeof(ModelCallFailureEvent))]
[JsonSerializable(typeof(ModelCallFailureRequestFingerprint))]
[JsonSerializable(typeof(ModelCallFinishedData))]
[JsonSerializable(typeof(ModelCallFinishedEvent))]
[JsonSerializable(typeof(ModelCallStartData))]
[JsonSerializable(typeof(ModelCallStartEvent))]
[JsonSerializable(typeof(OmittedBinaryResult))]
[JsonSerializable(typeof(PendingMessagesModifiedData))]
[JsonSerializable(typeof(PendingMessagesModifiedEvent))]
[JsonSerializable(typeof(PermissionAssistedApproval))]
[JsonSerializable(typeof(PermissionCompletedData))]
[JsonSerializable(typeof(PermissionCompletedEvent))]
[JsonSerializable(typeof(PermissionPromptRequest))]
[JsonSerializable(typeof(PermissionPromptRequestCommands))]
[JsonSerializable(typeof(PermissionPromptRequestCustomTool))]
[JsonSerializable(typeof(PermissionPromptRequestExtensionEnvAccess))]
[JsonSerializable(typeof(PermissionPromptRequestExtensionManagement))]
[JsonSerializable(typeof(PermissionPromptRequestExtensionPermissionAccess))]
[JsonSerializable(typeof(PermissionPromptRequestFactory))]
[JsonSerializable(typeof(PermissionPromptRequestHook))]
[JsonSerializable(typeof(PermissionPromptRequestMcp))]
[JsonSerializable(typeof(PermissionPromptRequestMemory))]
[JsonSerializable(typeof(PermissionPromptRequestPath))]
[JsonSerializable(typeof(PermissionPromptRequestRead))]
[JsonSerializable(typeof(PermissionPromptRequestUrl))]
[JsonSerializable(typeof(PermissionPromptRequestWrite))]
[JsonSerializable(typeof(PermissionRequest))]
[JsonSerializable(typeof(PermissionRequestCustomTool))]
[JsonSerializable(typeof(PermissionRequestExtensionEnvAccess))]
[JsonSerializable(typeof(PermissionRequestExtensionManagement))]
[JsonSerializable(typeof(PermissionRequestExtensionPermissionAccess))]
[JsonSerializable(typeof(PermissionRequestFactory))]
[JsonSerializable(typeof(PermissionRequestHook))]
[JsonSerializable(typeof(PermissionRequestMcp))]
[JsonSerializable(typeof(PermissionRequestMemory))]
[JsonSerializable(typeof(PermissionRequestRead))]
[JsonSerializable(typeof(PermissionRequestShell))]
[JsonSerializable(typeof(PermissionRequestShellCommand))]
[JsonSerializable(typeof(PermissionRequestShellCommandSegment))]
[JsonSerializable(typeof(PermissionRequestShellPossibleUrl))]
[JsonSerializable(typeof(PermissionRequestUrl))]
[JsonSerializable(typeof(PermissionRequestWrite))]
[JsonSerializable(typeof(PermissionRequestedData))]
[JsonSerializable(typeof(PermissionRequestedEvent))]
[JsonSerializable(typeof(PermissionResult))]
[JsonSerializable(typeof(PermissionResultApproved))]
[JsonSerializable(typeof(PermissionResultApprovedForLocation))]
[JsonSerializable(typeof(PermissionResultApprovedForSession))]
[JsonSerializable(typeof(PermissionResultCancelled))]
[JsonSerializable(typeof(PermissionResultDeniedByContentExclusionPolicy))]
[JsonSerializable(typeof(PermissionResultDeniedByPermissionRequestHook))]
[JsonSerializable(typeof(PermissionResultDeniedByRules))]
[JsonSerializable(typeof(PermissionResultDeniedInteractivelyByUser))]
[JsonSerializable(typeof(PermissionResultDeniedNoApprovalRuleAndCouldNotRequestFromUser))]
[JsonSerializable(typeof(PermissionRule))]
[JsonSerializable(typeof(PersistedBinaryImage))]
[JsonSerializable(typeof(PersistedBinaryResult))]
[JsonSerializable(typeof(PromptCacheBreakData))]
[JsonSerializable(typeof(PromptCacheBreakEvent))]
[JsonSerializable(typeof(SamplingCompletedData))]
[JsonSerializable(typeof(SamplingCompletedEvent))]
[JsonSerializable(typeof(SamplingRequestedData))]
[JsonSerializable(typeof(SamplingRequestedEvent))]
[JsonSerializable(typeof(SandboxDecisionData))]
[JsonSerializable(typeof(SandboxDecisionEvent))]
[JsonSerializable(typeof(SessionAutoModeResolvedData))]
[JsonSerializable(typeof(SessionAutoModeResolvedEvent))]
[JsonSerializable(typeof(SessionAutoTierSwitchFailedData))]
[JsonSerializable(typeof(SessionAutoTierSwitchFailedEvent))]
[JsonSerializable(typeof(SessionAutopilotObjectiveChangedData))]
[JsonSerializable(typeof(SessionAutopilotObjectiveChangedEvent))]
[JsonSerializable(typeof(SessionBackgroundTasksChangedData))]
[JsonSerializable(typeof(SessionBackgroundTasksChangedEvent))]
[JsonSerializable(typeof(SessionBinaryAssetData))]
[JsonSerializable(typeof(SessionBinaryAssetEvent))]
[JsonSerializable(typeof(SessionCanvasClosedData))]
[JsonSerializable(typeof(SessionCanvasClosedEvent))]
[JsonSerializable(typeof(SessionCanvasOpenedData))]
[JsonSerializable(typeof(SessionCanvasOpenedEvent))]
[JsonSerializable(typeof(SessionCanvasRecordedData))]
[JsonSerializable(typeof(SessionCanvasRecordedEvent))]
[JsonSerializable(typeof(SessionCanvasRegistryChangedData))]
[JsonSerializable(typeof(SessionCanvasRegistryChangedEvent))]
[JsonSerializable(typeof(SessionCanvasRemovedData))]
[JsonSerializable(typeof(SessionCanvasRemovedEvent))]
[JsonSerializable(typeof(SessionCanvasUnavailableData))]
[JsonSerializable(typeof(SessionCanvasUnavailableEvent))]
[JsonSerializable(typeof(SessionCompactionCompleteData))]
[JsonSerializable(typeof(SessionCompactionCompleteEvent))]
[JsonSerializable(typeof(SessionCompactionStartData))]
[JsonSerializable(typeof(SessionCompactionStartEvent))]
[JsonSerializable(typeof(SessionCompletionReceiptData))]
[JsonSerializable(typeof(SessionCompletionReceiptEvent))]
[JsonSerializable(typeof(SessionContextChangedData))]
[JsonSerializable(typeof(SessionContextChangedEvent))]
[JsonSerializable(typeof(SessionContextClearedData))]
[JsonSerializable(typeof(SessionContextClearedEvent))]
[JsonSerializable(typeof(SessionCustomAgentsUpdatedData))]
[JsonSerializable(typeof(SessionCustomAgentsUpdatedEvent))]
[JsonSerializable(typeof(SessionCustomNotificationData))]
[JsonSerializable(typeof(SessionCustomNotificationEvent))]
[JsonSerializable(typeof(SessionErrorData))]
[JsonSerializable(typeof(SessionErrorEvent))]
[JsonSerializable(typeof(SessionEvent))]
[JsonSerializable(typeof(SessionExtensionsAttachmentsPushedData))]
[JsonSerializable(typeof(SessionExtensionsAttachmentsPushedEvent))]
[JsonSerializable(typeof(SessionExtensionsLoadedData))]
[JsonSerializable(typeof(SessionExtensionsLoadedEvent))]
[JsonSerializable(typeof(SessionFusionCompletedData))]
[JsonSerializable(typeof(SessionFusionCompletedEvent))]
[JsonSerializable(typeof(SessionFusionResolvedData))]
[JsonSerializable(typeof(SessionFusionResolvedEvent))]
[JsonSerializable(typeof(SessionFusionRouteFailedData))]
[JsonSerializable(typeof(SessionFusionRouteFailedEvent))]
[JsonSerializable(typeof(SessionFusionRouteStartedData))]
[JsonSerializable(typeof(SessionFusionRouteStartedEvent))]
[JsonSerializable(typeof(SessionHandoffData))]
[JsonSerializable(typeof(SessionHandoffEvent))]
[JsonSerializable(typeof(SessionIdleData))]
[JsonSerializable(typeof(SessionIdleEvent))]
[JsonSerializable(typeof(SessionInfoData))]
[JsonSerializable(typeof(SessionInfoEvent))]
[JsonSerializable(typeof(SessionLimitsConfig))]
[JsonSerializable(typeof(SessionLimitsExhaustedCompletedData))]
[JsonSerializable(typeof(SessionLimitsExhaustedCompletedEvent))]
[JsonSerializable(typeof(SessionLimitsExhaustedRequestedData))]
[JsonSerializable(typeof(SessionLimitsExhaustedRequestedEvent))]
[JsonSerializable(typeof(SessionLimitsExhaustedResponse))]
[JsonSerializable(typeof(SessionManagedSettingsEnforcedData))]
[JsonSerializable(typeof(SessionManagedSettingsEnforcedEvent))]
[JsonSerializable(typeof(SessionManagedSettingsResolvedData))]
[JsonSerializable(typeof(SessionManagedSettingsResolvedEvent))]
[JsonSerializable(typeof(SessionMcpServerNeedsReconnectData))]
[JsonSerializable(typeof(SessionMcpServerNeedsReconnectEvent))]
[JsonSerializable(typeof(SessionMcpServerRemovedData))]
[JsonSerializable(typeof(SessionMcpServerRemovedEvent))]
[JsonSerializable(typeof(SessionMcpServerStatusChangedData))]
[JsonSerializable(typeof(SessionMcpServerStatusChangedEvent))]
[JsonSerializable(typeof(SessionMcpServersLoadedData))]
[JsonSerializable(typeof(SessionMcpServersLoadedEvent))]
[JsonSerializable(typeof(SessionModeChangedData))]
[JsonSerializable(typeof(SessionModeChangedEvent))]
[JsonSerializable(typeof(SessionModeNoticeDeliveredData))]
[JsonSerializable(typeof(SessionModeNoticeDeliveredEvent))]
[JsonSerializable(typeof(SessionModelChangeData))]
[JsonSerializable(typeof(SessionModelChangeEvent))]
[JsonSerializable(typeof(SessionPermissionsChangedData))]
[JsonSerializable(typeof(SessionPermissionsChangedEvent))]
[JsonSerializable(typeof(SessionPlanChangedData))]
[JsonSerializable(typeof(SessionPlanChangedEvent))]
[JsonSerializable(typeof(SessionRemoteSteerableChangedData))]
[JsonSerializable(typeof(SessionRemoteSteerableChangedEvent))]
[JsonSerializable(typeof(SessionResumeData))]
[JsonSerializable(typeof(SessionResumeEvent))]
[JsonSerializable(typeof(SessionScheduleCancelledData))]
[JsonSerializable(typeof(SessionScheduleCancelledEvent))]
[JsonSerializable(typeof(SessionScheduleCreatedData))]
[JsonSerializable(typeof(SessionScheduleCreatedEvent))]
[JsonSerializable(typeof(SessionScheduleRearmedData))]
[JsonSerializable(typeof(SessionScheduleRearmedEvent))]
[JsonSerializable(typeof(SessionSessionLimitsChangedData))]
[JsonSerializable(typeof(SessionSessionLimitsChangedEvent))]
[JsonSerializable(typeof(SessionShutdownData))]
[JsonSerializable(typeof(SessionShutdownEvent))]
[JsonSerializable(typeof(SessionSkillsLoadedData))]
[JsonSerializable(typeof(SessionSkillsLoadedEvent))]
[JsonSerializable(typeof(SessionSnapshotRewindData))]
[JsonSerializable(typeof(SessionSnapshotRewindEvent))]
[JsonSerializable(typeof(SessionStartData))]
[JsonSerializable(typeof(SessionStartEvent))]
[JsonSerializable(typeof(SessionTaskCompleteData))]
[JsonSerializable(typeof(SessionTaskCompleteEvent))]
[JsonSerializable(typeof(SessionTitleChangedData))]
[JsonSerializable(typeof(SessionTitleChangedEvent))]
[JsonSerializable(typeof(SessionTodosChangedData))]
[JsonSerializable(typeof(SessionTodosChangedEvent))]
[JsonSerializable(typeof(SessionToolsUpdatedData))]
[JsonSerializable(typeof(SessionToolsUpdatedEvent))]
[JsonSerializable(typeof(SessionTruncationData))]
[JsonSerializable(typeof(SessionTruncationEvent))]
[JsonSerializable(typeof(SessionUsageCheckpointData))]
[JsonSerializable(typeof(SessionUsageCheckpointEvent))]
[JsonSerializable(typeof(SessionUsageInfoData))]
[JsonSerializable(typeof(SessionUsageInfoEvent))]
[JsonSerializable(typeof(SessionWarningData))]
[JsonSerializable(typeof(SessionWarningEvent))]
[JsonSerializable(typeof(SessionWorkspaceFileChangedData))]
[JsonSerializable(typeof(SessionWorkspaceFileChangedEvent))]
[JsonSerializable(typeof(ShutdownAgentMetric))]
[JsonSerializable(typeof(ShutdownCodeChanges))]
[JsonSerializable(typeof(ShutdownModelMetric))]
[JsonSerializable(typeof(ShutdownModelMetricRequests))]
[JsonSerializable(typeof(ShutdownModelMetricTokenDetail))]
[JsonSerializable(typeof(ShutdownModelMetricUsage))]
[JsonSerializable(typeof(ShutdownTokenDetail))]
[JsonSerializable(typeof(SkillInvokedData))]
[JsonSerializable(typeof(SkillInvokedEvent))]
[JsonSerializable(typeof(SkillsLoadedSkill))]
[JsonSerializable(typeof(SubagentCompletedData))]
[JsonSerializable(typeof(SubagentCompletedEvent))]
[JsonSerializable(typeof(SubagentConfiguredData))]
[JsonSerializable(typeof(SubagentConfiguredEvent))]
[JsonSerializable(typeof(SubagentDeselectedData))]
[JsonSerializable(typeof(SubagentDeselectedEvent))]
[JsonSerializable(typeof(SubagentFailedData))]
[JsonSerializable(typeof(SubagentFailedEvent))]
[JsonSerializable(typeof(SubagentSelectedData))]
[JsonSerializable(typeof(SubagentSelectedEvent))]
[JsonSerializable(typeof(SubagentStartedData))]
[JsonSerializable(typeof(SubagentStartedEvent))]
[JsonSerializable(typeof(SystemMessageData))]
[JsonSerializable(typeof(SystemMessageEvent))]
[JsonSerializable(typeof(SystemMessageMetadata))]
[JsonSerializable(typeof(SystemNotification))]
[JsonSerializable(typeof(SystemNotificationAgentCompleted))]
[JsonSerializable(typeof(SystemNotificationAgentIdle))]
[JsonSerializable(typeof(SystemNotificationData))]
[JsonSerializable(typeof(SystemNotificationEvent))]
[JsonSerializable(typeof(SystemNotificationFactoryCompleted))]
[JsonSerializable(typeof(SystemNotificationInstructionDiscovered))]
[JsonSerializable(typeof(SystemNotificationNewInboxMessage))]
[JsonSerializable(typeof(SystemNotificationShellCompleted))]
[JsonSerializable(typeof(SystemNotificationShellDetachedCompleted))]
[JsonSerializable(typeof(SystemNotificationUnclassified))]
[JsonSerializable(typeof(ToolExecutionCompleteContent))]
[JsonSerializable(typeof(ToolExecutionCompleteContentAudio))]
[JsonSerializable(typeof(ToolExecutionCompleteContentImage))]
[JsonSerializable(typeof(ToolExecutionCompleteContentResource))]
[JsonSerializable(typeof(ToolExecutionCompleteContentResourceDetails))]
[JsonSerializable(typeof(ToolExecutionCompleteContentResourceLink))]
[JsonSerializable(typeof(ToolExecutionCompleteContentResourceLinkIcon))]
[JsonSerializable(typeof(ToolExecutionCompleteContentShellExit))]
[JsonSerializable(typeof(ToolExecutionCompleteContentTerminal))]
[JsonSerializable(typeof(ToolExecutionCompleteContentText))]
[JsonSerializable(typeof(ToolExecutionCompleteData))]
[JsonSerializable(typeof(ToolExecutionCompleteError))]
[JsonSerializable(typeof(ToolExecutionCompleteEvent))]
[JsonSerializable(typeof(ToolExecutionCompleteResult))]
[JsonSerializable(typeof(ToolExecutionCompleteToolDescription))]
[JsonSerializable(typeof(ToolExecutionCompleteToolDescriptionMeta))]
[JsonSerializable(typeof(ToolExecutionCompleteToolDescriptionMetaUI))]
[JsonSerializable(typeof(ToolExecutionCompleteUIResource))]
[JsonSerializable(typeof(ToolExecutionCompleteUIResourceMeta))]
[JsonSerializable(typeof(ToolExecutionCompleteUIResourceMetaUI))]
[JsonSerializable(typeof(ToolExecutionCompleteUIResourceMetaUICsp))]
[JsonSerializable(typeof(ToolExecutionCompleteUIResourceMetaUIPermissions))]
[JsonSerializable(typeof(ToolExecutionCompleteUIResourceMetaUIPermissionsCamera))]
[JsonSerializable(typeof(ToolExecutionCompleteUIResourceMetaUIPermissionsClipboardWrite))]
[JsonSerializable(typeof(ToolExecutionCompleteUIResourceMetaUIPermissionsGeolocation))]
[JsonSerializable(typeof(ToolExecutionCompleteUIResourceMetaUIPermissionsMicrophone))]
[JsonSerializable(typeof(ToolExecutionPartialResultData))]
[JsonSerializable(typeof(ToolExecutionPartialResultEvent))]
[JsonSerializable(typeof(ToolExecutionProgressData))]
[JsonSerializable(typeof(ToolExecutionProgressEvent))]
[JsonSerializable(typeof(ToolExecutionStartData))]
[JsonSerializable(typeof(ToolExecutionStartEvent))]
[JsonSerializable(typeof(ToolExecutionStartShellToolInfo))]
[JsonSerializable(typeof(ToolExecutionStartToolDescription))]
[JsonSerializable(typeof(ToolExecutionStartToolDescriptionMeta))]
[JsonSerializable(typeof(ToolExecutionStartToolDescriptionMetaUI))]
[JsonSerializable(typeof(ToolSearchActivatedData))]
[JsonSerializable(typeof(ToolSearchActivatedEvent))]
[JsonSerializable(typeof(ToolUserRequestedData))]
[JsonSerializable(typeof(ToolUserRequestedEvent))]
[JsonSerializable(typeof(UiEphemeralQueryData))]
[JsonSerializable(typeof(UiEphemeralQueryEvent))]
[JsonSerializable(typeof(UsageCheckpointModelCacheState))]
[JsonSerializable(typeof(UserInputCompletedData))]
[JsonSerializable(typeof(UserInputCompletedEvent))]
[JsonSerializable(typeof(UserInputRequestedData))]
[JsonSerializable(typeof(UserInputRequestedEvent))]
[JsonSerializable(typeof(UserMessageData))]
[JsonSerializable(typeof(UserMessageEvent))]
[JsonSerializable(typeof(UserToolSessionApproval))]
[JsonSerializable(typeof(UserToolSessionApprovalCommands))]
[JsonSerializable(typeof(UserToolSessionApprovalCustomTool))]
[JsonSerializable(typeof(UserToolSessionApprovalExtensionEnvAccess))]
[JsonSerializable(typeof(UserToolSessionApprovalExtensionManagement))]
[JsonSerializable(typeof(UserToolSessionApprovalExtensionPermissionAccess))]
[JsonSerializable(typeof(UserToolSessionApprovalFactory))]
[JsonSerializable(typeof(UserToolSessionApprovalMcp))]
[JsonSerializable(typeof(UserToolSessionApprovalMemory))]
[JsonSerializable(typeof(UserToolSessionApprovalRead))]
[JsonSerializable(typeof(UserToolSessionApprovalWrite))]
[JsonSerializable(typeof(WorkingDirectoryContext))]
[JsonSerializable(typeof(JsonElement))]
internal sealed partial class SessionEventsJsonContext : JsonSerializerContext;