Instance data types

struct AgentInteraction {
    pub id: Uuid,
    pub timestamp: DateTime<Utc>,
    pub from_agent: String,
    pub to_agent: String,
    pub interaction_type: InteractionType,
    pub message: String,
    pub context: HashMap<String, serde_json::Value>,
    pub response: Option<InteractionResponse>,
}

struct AnalyticsSourceCore {
    name: String,
    keyspace: String,
    collection: String,
}

struct AnalyticsSourceCsv {
    name: String,
    path: String,
}

struct AnalyticsSourceParquet {
    name: String,
    path: String,
}

struct AnalyticsViewCreateReq {
    name: String,
    query: String,
}

enum BackendKind {
    Local,
    Modal,
    Baseten,
    External { name: String },
}

enum BackendOperationalStatus {
    Online,
    Degraded,
    Offline,
    Unknown,
}

struct BackendRuntimeReport {
    pub backend: BackendKind,
    pub status: BackendOperationalStatus,
    #[serde(default)]
    pub queue_depth: usize,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub avg_latency_ms: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub p95_latency_ms: Option<f64>,
    pub throughput_per_min: f64,
    pub retry_rate: f64,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub sparkline: Vec<u64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_error: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_error_at: Option<DateTime<Utc>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_updated: Option<DateTime<Utc>>,
}

struct BackendTelemetrySnapshot {
    pub backend: BackendKind,
    pub attempts: u8,
    pub retries: u8,
    pub backend_latency_ms: u64,
    pub total_latency_ms: u64,
    pub emitted_at: DateTime<Utc>,
    #[serde(default, skip_serializing_if = "HashMap::is_empty")]
    pub annotations: HashMap<String, Value>,
}

struct BackupCreateRequest {
    backup_dir: String,
    #[serde(default)]
    options: Option<akasha::CoreBackupOptions>,
}

struct BackupDeleteRequest {
    backup_dir: String,
    id: String,
}

struct BackupListRequest {
    backup_dir: String,
}

struct BackupRestoreRequest {
    backup_dir: String,
    id: String,
    #[serde(default)]
    options: Option<akasha::CoreRestoreOptions>,
}

struct CambiumProjectionEnvelope {
    projection_id: String,
    target: String,
    sink_id: String,
    projection_class: String,
    source_event_id: String,
    stream_id: String,
    sequence: u64,
    global_sequence: u64,
    trace_id: Option<String>,
    span_id: Option<String>,
    scope: Value,
    lineage: Value,
    data_class: String,
    redaction_profile: String,
    source_payload_hash: String,
    #[serde(default)]
    evidence_refs: Vec<String>,
    activity_summary: Option<String>,
    tool_id: Option<String>,
    #[serde(rename = "toolScoreSample", default)]
    _tool_score_sample: Option<Value>,
    derived: bool,
    created_at: String,
}

struct ChunkTextRequest {
    text: String,
    /// Optional per-request chunking configuration override.
    config: Option<chunking::ChunkingConfig>,
}

struct ChunkingConfig {
    /// Maximum chunk size in characters (default: 2048).
    #[serde(default = "default_max_chunk_size")]
    pub max_chunk_size: usize,
    /// Overlap between consecutive chunks in characters (default: 200).
    #[serde(default = "default_overlap")]
    pub overlap: usize,
    /// Chunking strategy to use.
    #[serde(default)]
    pub strategy: ChunkingStrategy,
}

enum ChunkingStrategy {
    /// Fixed-size sliding window.
    SlidingWindow,
    /// Split on sentence boundaries.
    #[default]
    SentenceBased,
    /// Split on paragraph boundaries (falls back to sentence-based for
    /// paragraphs exceeding `max_chunk_size`).
    ParagraphBased,
}

struct CognitiveDecisionReq {
    decision: CognitiveDecision,
}

struct CognitiveDecision {
    /// Unique identifier
    pub id: Uuid,
    /// Agent that made the decision
    pub agent_id: String,
    /// Timestamp of decision
    pub timestamp: DateTime<Utc>,
    /// The decision made
    pub decision: String,
    /// Options that were considered
    pub options_considered: Vec<DecisionOption>,
    /// Reasoning that led to this decision
    pub reasoning_trace: Vec<Uuid>, // References to CognitiveThought IDs
    /// Confidence in the decision
    pub confidence: f32,
    /// Expected outcomes
    pub expected_outcomes: Vec<String>,
    /// Actual outcomes (filled in later)
    pub actual_outcomes: Option<Vec<String>>,
}

struct CognitiveInteractionReq {
    interaction: AgentInteraction,
}

struct CognitiveQueryReq {
    query: serde_json::Value,
}

struct CognitiveRunCycleReq {
    input: serde_json::Value,
    trigger: Option<String>,
}

struct CognitiveSessionReq {
    agent_id: String,
    goal: String,
}

struct CognitiveThoughtReq {
    thought: CognitiveThought,
}

struct CognitiveThought {
    /// Unique identifier for this thought
    pub id: Uuid,
    /// The agent that generated this thought
    pub agent_id: String,
    /// Timestamp when the thought occurred
    pub timestamp: DateTime<Utc>,
    /// Type of cognitive operation
    pub thought_type: ThoughtType,
    /// The actual thought content
    pub content: String,
    /// Confidence level (0.0 to 1.0)
    pub confidence: f32,
    /// Parent thought ID if this is a sub-thought
    pub parent_thought_id: Option<Uuid>,
    /// Related context or evidence
    pub context: HashMap<String, serde_json::Value>,
    /// Tags for categorization
    pub tags: Vec<String>,
}

struct ComponentsRequest {
    strong: Option<bool>,
}

struct ContinualComponentReq {
    #[allow(dead_code)]
    id: String,
}

struct ContinualRecoverReq {
    #[allow(dead_code)]
    checkpoint_id: String,
}

struct ContinualTaskConsolidateReq {
    #[serde(default)]
    namespace: Option<String>,
}

struct ContinualTaskDeleteReq {
    task_id: String,
}

struct ContinualTaskEvaluateReq {
    task_id: String,
    test_data: Option<Vec<serde_json::Value>>,
}

struct ContinualTaskNewReq {
    name: String,
    description: Option<String>,
}

struct ContinualTaskPauseReq {
    #[allow(dead_code)]
    task_id: Option<String>,
}

struct ContinualTaskStatsReq {
    namespace: Option<String>,
}

struct ContinualTaskTrainReq {
    task_id: String,
    training_data: Vec<serde_json::Value>,
}

struct CoreTextSearchRequest {
    keyspace: String,
    query: String,
    limit: Option<usize>,
}

struct CreateForgettingRequest {
    /// Human-readable reason for the deletion request
    reason: String,
    /// The keyspace containing the target record(s)
    target_keyspace: String,
    /// IDs of the records to be deleted
    target_ids: Vec<String>,
    /// Optional requester identifier
    requester: Option<String>,
}

struct CreateKeyspaceRequest {
    name: String,
    model: String,
    dims: Option<usize>,
    #[serde(default)]
    domain: Option<String>,
    #[serde(default)]
    schema_version: Option<u32>,
    #[serde(default)]
    schema: Option<serde_json::Value>,
    #[serde(default)]
    strict: Option<bool>,
    #[serde(default)]
    metadata: Option<HashMap<String, serde_json::Value>>,
    #[serde(default)]
    description: Option<String>,
}

struct CypherLiteRequest {
    query: String,
    allow_updates: Option<bool>,
    enforce_transactions: Option<bool>,
    temporal: Option<TemporalClauseRequest>,
}

struct CypherRequest {
    query: String,
}

struct DecisionOption {
    pub option: String,
    pub pros: Vec<String>,
    pub cons: Vec<String>,
    pub score: f32,
    pub rejected_reason: Option<String>,
}

enum DisableServiceRequest {
    Single { service: String },
    Multiple { services: Vec<String> },
}

struct DisableServiceResponse {
    success: bool,
    updates: Vec<ServiceMutationResponse>,
    failed_services: Vec<FailedService>,
}

struct EmbedRequest {
    text: String,
    /// When true, long text is automatically chunked and each chunk is
    /// embedded separately.  The response contains a `vectors` array instead
    /// of a single `vector`.
    #[serde(default)]
    chunk: bool,
    /// Optional per-request chunking overrides.
    chunking: Option<chunking::ChunkingConfig>,
}

struct EmbeddingDto {
    pub algorithm: String,
    pub dim: u32,
    pub vector: Vec<f32>,
}

struct EmissionRecordRequest {
    pub perception_id: String,
    pub ir_id: String,
    pub modality: ModalityDto,
    pub signer: String,
    pub embedding: EmbeddingDto,
}

enum EnableServiceRequest {
    /// Enable single service: {"service": "analytics"}
    Single { service: String },
    /// Enable multiple services: {"services": ["analytics", "graph"]}
    Multiple { services: Vec<String> },
}

struct EnableServiceResponse {
    success: bool,
    updates: Vec<ServiceMutationResponse>,
    failed_services: Vec<FailedService>,
}

struct EnsembleInfo {
    pub ensemble_id: String,
    pub n_neurons: i32,
    pub dimensions: i32,
    #[serde(default)]
    pub specializations: Vec<String>,
}

struct EnsureCompositeIndexRequest {
    properties: Vec<String>,
}

struct EnsurePropertyIndexRequest {
    property_name: String,
}

struct EpisodicInsertRequest {
    event: EpisodicEvent,
}

struct EpisodicSearchReq {
    text: Option<String>,
    query: Option<String>,
    limit: Option<usize>,
}

struct EpisodicUpdateRequest {
    event: EpisodicEvent,
}

struct ExecutionContext {
    pub environment: Option<String>, // dev, staging, prod
    pub required_tools: Vec<String>, // Required tools or dependencies
    pub permissions: Vec<String>,    // Required permissions
    pub estimated_duration_mins: Option<u32>,
    pub risk_level: RiskLevel,
    pub prerequisites: Vec<Uuid>, // Other procedures that must be run first
}

struct FailedService {
    name: String,
    reason: String,
    code: String,
}

struct GraphFulltextRequest {
    query: String,
    limit: Option<usize>,
}

struct GraphTxIdReq {
    id: String,
}

struct InferenceJobQuery {
    limit: Option<usize>,
}

struct InferenceModelListResponse {
    models: Vec<ModelMetadata>,
}

struct InferenceModelQuery {
    tenant: Option<String>,
    backend: Option<String>,
    family: Option<String>,
    status: Option<String>,
    search: Option<String>,
}

enum InferencePayload {
    Text {
        prompt: String,
    },
    Json {
        value: Value,
    },
    Tensor {
        shape: Vec<usize>,
        values: Vec<f32>,
    },
    #[serde(with = "serde_bytes")]
    Binary {
        data: Vec<u8>,
    },
}

struct InferenceResultEnvelope {
    pub model_id: String,
    pub tenant_id: String,
    pub outputs: Vec<Value>,
    pub latency_ms: u64,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tokens_used: Option<u64>,
    pub backend: BackendKind,
    pub telemetry: BackendTelemetrySnapshot,
    #[serde(default)]
    pub metadata: HashMap<String, Value>,
}

struct InferenceUpdateStatusRequest {
    status: ModelStatus,
}

enum IngestKind {
    #[serde(rename = "triples")]
    Triples {
        triples: Vec<akasha::adapters::Triple>,
    },
    #[serde(rename = "document")]
    Document { document: serde_json::Value },
    #[serde(rename = "entities")]
    Entities { entities: Vec<serde_json::Value> },
}

struct IngestRequest {
    kind: IngestKind,
    content_type: String,
}

struct InteractionResponse {
    pub timestamp: DateTime<Utc>,
    pub response: String,
    pub success: bool,
    pub metadata: HashMap<String, serde_json::Value>,
}

enum InteractionType {
    Query,
    Request,
    Inform,
    Delegate,
    Collaborate,
    Negotiate,
    Conflict,
    Consensus,
}

struct JobOverview {
    pub id: Uuid,
    pub backend: BackendKind,
    pub tenant_id: String,
    pub model_id: String,
    pub status: JobStatus,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_error: Option<String>,
    pub retryable: bool,
    pub cancellable: bool,
}

enum JobStatus {
    Pending {
        queued_at: DateTime<Utc>,
    },
    Running {
        started_at: DateTime<Utc>,
    },
    Completed {
        finished_at: DateTime<Utc>,
        result: Box<InferenceResultEnvelope>,
    },
    Failed {
        finished_at: DateTime<Utc>,
        error: String,
    },
    Cancelled {
        finished_at: DateTime<Utc>,
    },
}

struct LineageGraphReq {
    root_id: Option<String>,
    depth: Option<u32>,
}

struct LineageImpactReq {
    node_id: String,
}

struct LineageVerifyReq {
    node_id: String,
}

struct LoadModelRequest {
    name: String,
    model_type: String,
    framework: String,
    path: Option<String>,
    data_b64: Option<String>,
}

struct LoadedModelInfo {
    id: String,
    name: String,
    memory_bytes: u64,
    uptime_seconds: u64,
}

struct McpToolsCallRequest {
    /// The name of the tool to call
    pub name: String,
    /// Arguments to pass to the tool
    #[serde(default)]
    pub arguments: JsonValue,
    /// Optional caller-supplied namespace used by Cambium recall augmentation.
    #[serde(default)]
    pub namespace: Option<String>,
}

struct McpToolsListRequest {}

struct MeteringSnapshot {
    pub tenant_id: String,
    pub model_id: String,
    pub total_requests: u64,
    pub total_tokens: u64,
    pub total_latency_ms: u64,
    pub window_started_at: DateTime<Utc>,
    #[serde(skip_serializing_if = "HashMap::is_empty", default)]
    pub extra: HashMap<String, Value>,
}

struct MhnClearReq {
    #[serde(flatten)]
    body_authority: RejectedBodyAuthority,
}

struct MhnConfigReq {
    #[serde(flatten)]
    body_authority: RejectedBodyAuthority,
}

struct MhnListReq {
    #[serde(flatten)]
    body_authority: RejectedBodyAuthority,
}

struct MhnNewReq {
    dimensions: usize,
    #[serde(flatten)]
    body_authority: RejectedBodyAuthority,
}

struct MhnRetrieveKeyReq {
    id: String,
    #[serde(flatten)]
    body_authority: RejectedBodyAuthority,
}

struct MhnRetrieveReq {
    vector: Vec<f32>,
    k: Option<usize>,
    #[serde(flatten)]
    body_authority: RejectedBodyAuthority,
}

struct MhnRetrieveVectorReq {
    vector: Vec<f32>,
    k: Option<usize>,
    #[serde(flatten)]
    body_authority: RejectedBodyAuthority,
}

struct MhnStatsReq {
    #[serde(flatten)]
    body_authority: RejectedBodyAuthority,
}

struct MhnStoreReq {
    id: String,
    vector: Vec<f32>,
    #[serde(flatten)]
    body_authority: RejectedBodyAuthority,
}

struct MhnSystemInfoReq {
    #[serde(flatten)]
    body_authority: RejectedBodyAuthority,
}

struct MicrotheoryKeyspaceRequest {
    name: String,
}

struct MicrotheorySwitchRequest {
    name: String,
}

struct MlGenerateRequest {
    model_id: String,
    prompt: String,
    max_tokens: Option<usize>,
    temperature: Option<f32>,
}

struct MlMetricsRequest {
    model_id: String,
}

struct MlSupervisedSample {
    features: Vec<f32>,
    label: usize,
}

struct MlTokenizerLoadReq {
    model_id: String,
}

struct MlTrainHrmReq {
    domain: String,
    dataspace: String,
    primitive_keyspace: String,
    checkpoint_name: String,
    #[serde(default)]
    reservoir_id: Option<String>,
    #[serde(default)]
    epochs: Option<usize>,
    #[serde(default)]
    batch_size: Option<usize>,
    model_config: serde_json::Value,
    training_config: serde_json::Value,
    #[serde(default)]
    #[allow(dead_code)]
    inputs: Option<Vec<serde_json::Value>>,
    #[serde(default)]
    #[allow(dead_code)]
    targets: Option<Vec<serde_json::Value>>,
}

struct MlTrainSupervisedReq {
    model_name: String,
    input_dim: usize,
    num_classes: usize,
    samples: Vec<MlSupervisedSample>,
    #[serde(default)]
    params: MlTrainingParams,
}

struct MlTrainingParams {
    learning_rate: Option<f64>,
    weight_decay: Option<f64>,
    epochs: Option<usize>,
    batch_size: Option<usize>,
}

enum ModalityDto {
    Audio,
    Vision,
    Video,
    Text,
    Ocr,
    Sensor(SensorKindDto),
}

struct ModelDownloadRequest {
    model_id: String,
    #[serde(default)]
    force: bool,
    #[serde(default = "default_verify_hash")]
    verify_hash: bool,
}

enum ModelFamily {
    Hrm,
    Snn,
    Llm,
    Multimodal,
    Custom(String),
}

struct ModelInfoResponse {
    id: String,
    name: String,
    status: String,
    tier: String,
    purpose: String,
    capabilities: Vec<String>,
    size_bytes: u64,
    size_human: String,
    parameters_human: String,
    memory_bytes: Option<u64>,
    load_time_ms: Option<u64>,
    path: Option<String>,
    description: String,
    context_length: usize,
    thinking_mode: bool,
    downloaded_at: Option<String>,
    loaded_at: Option<String>,
    last_error: Option<String>,
}

struct ModelLoadRequest {
    model_id: String,
    #[serde(default)]
    force_download: bool,
}

struct ModelOpResponse {
    success: bool,
    model_id: String,
    status: String,
    message: String,
}

struct ModelsListResponse {
    models: Vec<ModelInfoResponse>,
    total: usize,
    memory_used_bytes: u64,
    memory_budget_bytes: u64,
}

struct ModelsMemoryResponse {
    memory_used_bytes: u64,
    memory_budget_bytes: u64,
    utilization_percent: f64,
    loaded_models: Vec<LoadedModelInfo>,
}

struct NamespaceSwitchReq {
    tenant_id: String,
    reservoir_id: String,
    agent_id: String,
    dataspace_id: String,
}

struct NsPathsFindReq {
    start: String,
    end: String,
}

struct NsPrefetchReq {
    #[allow(dead_code)]
    query: String,
}

struct NsRetrieveReq {
    text: String,
    mode: Option<String>,
    k: Option<usize>,
}

struct NsRuleToggleReq {
    #[allow(dead_code)]
    rule_id: String,
    #[allow(dead_code)]
    enabled: bool,
}

struct PagerankRequest {
    damping: Option<f64>,
}

struct PrimitiveExportRequest {
    keyspace: String,
    schema_version: Option<u32>,
}

struct PrimitiveImportRequest {
    keyspace: String,
    records: Vec<serde_json::Value>,
    schema_version: Option<u32>,
    #[serde(default)]
    upsert: bool,
}

struct ProceduralStoreRequest {
    procedure: Procedure,
}

struct ProcedureIdReq {
    id: String,
}

struct ProcedureSearchReq {
    query: String,
}

struct ProcedureStep {
    pub id: Uuid,
    pub sequence: u32,
    pub name: String,
    pub description: String,
    pub commands: Vec<String>,
    pub expected_output: Option<String>,
    pub timeout_seconds: Option<u32>,
    pub retry_count: u32,
    pub required_permissions: Vec<String>,
    pub dependencies: Vec<Uuid>,
    pub validation_criteria: Vec<String>,
}

enum ProcedureType {
    Workflow,        // Business process workflows
    Script,          // Executable scripts
    Recipe,          // Step-by-step instructions
    Algorithm,       // Mathematical/computational procedures
    Protocol,        // Communication or API protocols
    Deployment,      // Deployment procedures
    Troubleshooting, // Diagnostic and fixing procedures
    Setup,           // Installation or configuration procedures
    Migration,       // Data or system migration procedures
    Manual,
    Automated,
    Hybrid,
    Emergency,
    Standard,
}

struct ProcedureUpdateReq {
    id: String,
    procedure: Procedure,
}

struct Procedure {
    pub id: Uuid,
    pub name: String,
    pub description: String,
    pub procedure_type: ProcedureType,
    pub version: String,
    pub author: String,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
    pub execution_context: ExecutionContext,
    pub steps: Vec<ProcedureStep>,
    pub tags: Vec<String>,
    pub success_criteria: Vec<String>,
    pub failure_conditions: Vec<String>,
    pub related_procedures: Vec<Uuid>,
    pub approval_required: bool,
    pub compiled_wasm: Option<Vec<u8>>, // Optional compiled WASM module
    pub usage_count: u32,
    pub success_rate: f32, // 0.0 to 1.0
}

struct PutRequest {
    data: serde_json::Value,
}

struct QuarantineListParams {
    status: Option<String>,
    limit: Option<usize>,
}

struct QueryRequest {
    filter: String,
    limit: Option<usize>,
    offset: Option<usize>,
}

struct QueueDepthEntry {
    pub backend: BackendKind,
    pub pending: usize,
    pub running: usize,
    pub failed: usize,
    pub cancelled: usize,
}

struct QueueSnapshot {
    pub queues: Vec<QueueDepthEntry>,
    pub jobs: Vec<JobOverview>,
}

struct RegisterModelRequest {
    model_id: String,
    tenant_id: String,
    owner: String,
    family: ModelFamily,
    backend: BackendKind,
    version: String,
    #[serde(default)]
    adapter_id: Option<String>,
    #[serde(default)]
    hrm_entrypoint: Option<String>,
    #[serde(default)]
    tags: Vec<String>,
    #[serde(default)]
    capabilities: Vec<String>,
    #[serde(default)]
    extra: Value,
    #[serde(default)]
    status: Option<ModelStatus>,
}

struct ReindexRequest {
    keyspace: String,
}

struct RejectedBodyAuthority {
    #[serde(default)]
    capability: Option<serde_json::Value>,
    #[serde(default)]
    actions: Option<serde_json::Value>,
}

struct ReplicationCreateReq {
    dest_data_dir: String,
    link_id: Option<String>,
}

struct ReplicationIdReq {
    id: String,
}

struct ResourceAccessReq {
    id: String,
    access: String,
}

struct ResourceChunksReq {
    #[allow(dead_code)]
    resource_id: String,
}

struct ResourceIdReq {
    id: String,
}

struct ResourceItem {
    pub id: Uuid,
    pub name: String,
    pub description: String,
    pub resource_type: ResourceType,
    pub mime_type: String,
    pub size_bytes: u64,
    pub checksum: String,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
    pub tags: Vec<String>,
    pub metadata: ResourceMetadata,
    /// Path or key to the actual binary data in blob storage
    pub storage_key: String,
    /// Whether the resource is available for access
    pub available: bool,
}

struct ResourceMetadata {
    pub file_name: String,
    pub file_size: u64,
    pub mime_type: String,
    pub checksum: String,
    pub created_at: chrono::DateTime<chrono::Utc>,
    pub accessed_at: Option<chrono::DateTime<chrono::Utc>>,
    pub tags: Vec<String>,
    pub custom_fields: std::collections::HashMap<String, serde_json::Value>,
    pub total_accesses: u64,
}

struct ResourceStoreRequest {
    resource: ResourceItem,
    data_b64: String,
}

struct ResourceTypeReq {
    kind: String,
}

enum ResourceType {
    Document,
    Image,
    Video,
    Audio,
    Archive,
    Code,
    Data,
    Model,
    Other(String),
}

struct ResourceUsageReq {
    id: String,
}

struct RetrievalReq {
    text: String,
    limit: Option<usize>,
    #[serde(default)]
    chunk: bool,
}

enum RiskLevel {
    Low,      // Safe operations, no risk of data loss
    Medium,   // Some risk, requires review
    High,     // High risk, requires approval and backup
    Critical, // Extremely dangerous, requires multiple approvals
}

struct RuntimeServiceEntry {
    pub name: String,
    pub enabled: bool,
    pub provisioned: bool,
    pub lifecycle: ServiceLifecycle,
    pub status: RuntimeServiceStatus,
    pub dependencies: Vec<String>,
    #[serde(with = "chrono::serde::ts_seconds")]
    pub last_transition: DateTime<Utc>,
    pub message: Option<String>,
}

enum RuntimeServiceStatus {
    Disabled,
    Running,
    Pending,
    RestartRequired,
    Failed,
}

enum SensitivityLevel {
    Public,
    Internal,
    Confidential,
    Secret,
    TopSecret,
    High,
}

enum ServiceLifecycle {
    HotReload,
    ColdRestart,
}

struct ServiceMutationResponse {
    name: String,
    status: RuntimeServiceStatus,
    lifecycle: ServiceLifecycle,
    enabled: bool,
    provisioned: bool,
    applied: bool,
    message: Option<String>,
}

struct ServiceStatusResponse {
    services: Vec<RuntimeServiceEntry>,
}

struct ShortestPathRequest {
    source: String,
    target: String,
}

struct SnnBuildReq {
    network_id: Option<String>,
    namespace: Option<String>,
    version: Option<String>,
    spec: Option<serde_json::Value>,
    #[serde(flatten)]
    body_authority: RejectedBodyAuthority,
}

struct SnnCompileReq {
    network_id: String,
    namespace: String,
    version: Option<String>,
    #[serde(flatten)]
    body_authority: RejectedBodyAuthority,
}

struct SnnFederationAgentRemoveReq {
    token: Option<String>,
    agent_id: String,
}

struct SnnFederationAgentUpdateReq {
    token: Option<String>,
    agent_id: String,
    visibility: Option<String>,
    trust_score: Option<f32>,
}

struct SnnFederationCapabilitiesReq {
    token: Option<String>,
    #[serde(default)]
    required: Option<Vec<String>>,
}

struct SnnFederationContributeReq {
    token: Option<String>,
    agent_id: String,
    deltas: WeightDeltas,
}

struct SnnFederationRegisterReq {
    token: Option<String>,
    agent_id: String,
    host: String,
    capabilities: Vec<String>,
    #[serde(default)]
    ensembles: Vec<EnsembleInfo>,
    visibility: Option<String>,
    #[serde(default)]
    trust_score: Option<f32>,
}

struct SnnFederationSpikeReq {
    token: Option<String>,
    event: SpikeEventPayload,
}

struct SnnFederationTokenReq {
    token: Option<String>,
}

struct SnnNeuronsReq {
    network_id: String,
}

struct SnnStateReq {
    namespace: String,
    #[serde(flatten)]
    body_authority: RejectedBodyAuthority,
}

struct SnnStepReq {
    network_id: String,
    namespace: String,
    version: Option<String>,
    input: Vec<f32>,
    #[serde(flatten)]
    body_authority: RejectedBodyAuthority,
}

struct SnnTrainBpttReq {
    network_id: String,
    namespace: String,
    version: Option<String>,
    steps: usize,
    #[serde(flatten)]
    body_authority: RejectedBodyAuthority,
}

struct SpikeEventPayload {
    pub source_agent_id: String,
    pub ensemble_id: String,
    pub neuron_indices: Vec<i32>,
    pub spike_times: Vec<f32>,
    pub intensity: f32,
}

struct SqlRequest {
    sql: String,
}

struct SubdomainQueryReq {
    namespace: String,
    domain: String,
    subdomain: String,
    limit: Option<usize>,
}

struct TemporalClauseRequest {
    valid_time: Option<i64>,
    transaction_time: Option<i64>,
    valid_range: Option<TemporalRangeRequest>,
}

struct TemporalRangeRequest {
    from: i64,
    to: i64,
}

struct TestGateRequest {
    item_id: String,
    gate: String, // "confidence-score" or "anomaly-detection"
    /// Optional threshold override (defaults per gate type)
    threshold: Option<f64>,
}

enum ThoughtType {
    /// Initial problem understanding
    ProblemAnalysis,
    /// Hypothesis generation
    Hypothesis,
    /// Evidence evaluation
    EvidenceEvaluation,
    /// Reasoning step
    Reasoning,
    /// Decision point
    Decision,
    /// Action planning
    Planning,
    /// Reflection on outcomes
    Reflection,
    /// Error or contradiction detection
    ErrorDetection,
    /// Learning or insight
    Learning,
    /// Communication with other agents
    Communication,
}