@sequenceholdings/agent-spec 0.1.1 → 0.1.3

package/dist/voice-api.d.ts

@@ -0,0 +1,1102 @@
+import { z } from 'zod';
+import { type VoiceScope } from './voice-common.js';
+import { voiceDraftSaveRequestSchema, voiceSkillCaptureRequestSchema, type VoiceDraft } from './voice-drafts.js';
+import { type VoiceToolBinding, type VoiceToolOperationRequirement } from './voice-authority.js';
+export declare const voiceErrorCodeSchema: z.ZodEnum<{
+    WAITING_FOR_IDLE: "WAITING_FOR_IDLE";
+    STALE_REVISION: "STALE_REVISION";
+    DEPENDENCY_MAINTENANCE: "DEPENDENCY_MAINTENANCE";
+    DISABLED: "DISABLED";
+    DENIED: "DENIED";
+    PROVIDER_FAILURE: "PROVIDER_FAILURE";
+    NOT_FOUND: "NOT_FOUND";
+    IDEMPOTENCY_CONFLICT: "IDEMPOTENCY_CONFLICT";
+    INVALID_DEFINITION: "INVALID_DEFINITION";
+    MODE_MISMATCH: "MODE_MISMATCH";
+    INVALID_BINDING: "INVALID_BINDING";
+    SOURCE_MISSING: "SOURCE_MISSING";
+    SOURCE_FORBIDDEN: "SOURCE_FORBIDDEN";
+    LIMIT_REACHED: "LIMIT_REACHED";
+    UNCERTAIN_OPERATION: "UNCERTAIN_OPERATION";
+    INCOMPLETE_EVIDENCE: "INCOMPLETE_EVIDENCE";
+}>;
+export declare const voiceErrorSchema: z.ZodObject<{
+    code: z.ZodEnum<{
+        WAITING_FOR_IDLE: "WAITING_FOR_IDLE";
+        STALE_REVISION: "STALE_REVISION";
+        DEPENDENCY_MAINTENANCE: "DEPENDENCY_MAINTENANCE";
+        DISABLED: "DISABLED";
+        DENIED: "DENIED";
+        PROVIDER_FAILURE: "PROVIDER_FAILURE";
+        NOT_FOUND: "NOT_FOUND";
+        IDEMPOTENCY_CONFLICT: "IDEMPOTENCY_CONFLICT";
+        INVALID_DEFINITION: "INVALID_DEFINITION";
+        MODE_MISMATCH: "MODE_MISMATCH";
+        INVALID_BINDING: "INVALID_BINDING";
+        SOURCE_MISSING: "SOURCE_MISSING";
+        SOURCE_FORBIDDEN: "SOURCE_FORBIDDEN";
+        LIMIT_REACHED: "LIMIT_REACHED";
+        UNCERTAIN_OPERATION: "UNCERTAIN_OPERATION";
+        INCOMPLETE_EVIDENCE: "INCOMPLETE_EVIDENCE";
+    }>;
+    message: z.ZodString;
+    correlationId: z.ZodString;
+}, z.core.$strict>;
+export type VoiceError = z.infer<typeof voiceErrorSchema>;
+export type VoiceResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: VoiceError;
+};
+export interface VoiceHumanCommandContext {
+    scope: VoiceScope;
+    actorPrincipalId: string;
+}
+export declare const voicePublishRequestSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    expectedDraftRevision: z.ZodNumber;
+    expectedDeploymentRevision: z.ZodNullable<z.ZodNumber>;
+    idempotencyKey: z.ZodString;
+    toolReviewConfirmations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        toolAlias: z.ZodString;
+        bindingHash: z.ZodString;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type VoicePublishRequest = z.infer<typeof voicePublishRequestSchema>;
+export declare const voicePublicationReadRequestSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    operationId: z.ZodString;
+}, z.core.$strict>;
+export declare const voicePublicationResponseSchema: z.ZodObject<{
+    operation: z.ZodObject<{
+        tenantId: z.ZodString;
+        environmentId: z.ZodString;
+        agentId: z.ZodString;
+        publicationOperationId: z.ZodString;
+        idempotencyKey: z.ZodString;
+        expectedDeploymentRevision: z.ZodNullable<z.ZodNumber>;
+        previousActiveReleaseId: z.ZodNullable<z.ZodString>;
+        candidateReleaseId: z.ZodNullable<z.ZodString>;
+        state: z.ZodEnum<{
+            PREPARING: "PREPARING";
+            FAILED: "FAILED";
+            RECONCILIATION_REQUIRED: "RECONCILIATION_REQUIRED";
+            WAITING_FOR_IDLE: "WAITING_FOR_IDLE";
+            ACTIVATING: "ACTIVATING";
+            SUCCEEDED: "SUCCEEDED";
+        }>;
+        revision: z.ZodNumber;
+        createdByPrincipalId: z.ZodString;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strict>;
+    activeReleaseId: z.ZodNullable<z.ZodString>;
+    deploymentRevision: z.ZodNumber;
+    desiredEnabled: z.ZodBoolean;
+    publicationPaused: z.ZodBoolean;
+    maintenancePaused: z.ZodBoolean;
+    sources: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"CURRENT">;
+        skillId: z.ZodString;
+        capturedContentHash: z.ZodString;
+        currentContentHash: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"CHANGED">;
+        skillId: z.ZodString;
+        capturedContentHash: z.ZodString;
+        currentContentHash: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"MISSING">;
+        skillId: z.ZodString;
+        capturedContentHash: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"FORBIDDEN">;
+        skillId: z.ZodString;
+        capturedContentHash: z.ZodString;
+    }, z.core.$strict>], "status">>;
+}, z.core.$strict>;
+export type VoicePublicationResponse = z.infer<typeof voicePublicationResponseSchema>;
+export declare const voicePublishValidationRequestSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    expectedDraftRevision: z.ZodNumber;
+}, z.core.$strict>;
+export declare const voicePublishValidationResponseSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    draftRevision: z.ZodNumber;
+    deploymentRevision: z.ZodNumber;
+    activeReleaseId: z.ZodNullable<z.ZodString>;
+    authoredDefinitionHash: z.ZodString;
+    localProjectionHash: z.ZodString;
+    sources: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"CURRENT">;
+        skillId: z.ZodString;
+        capturedContentHash: z.ZodString;
+        currentContentHash: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"CHANGED">;
+        skillId: z.ZodString;
+        capturedContentHash: z.ZodString;
+        currentContentHash: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"MISSING">;
+        skillId: z.ZodString;
+        capturedContentHash: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"FORBIDDEN">;
+        skillId: z.ZodString;
+        capturedContentHash: z.ZodString;
+    }, z.core.$strict>], "status">>;
+    tools: z.ZodArray<z.ZodObject<{
+        binding: z.ZodObject<{
+            toolAlias: z.ZodString;
+            operation: z.ZodString;
+            managedFunctionId: z.ZodString;
+            functionVersionId: z.ZodString;
+            sourceHash: z.ZodString;
+            manifestHash: z.ZodString;
+            dataBinding: z.ZodObject<{
+                attachedIdentityId: z.ZodString;
+                dataScopeHash: z.ZodString;
+            }, z.core.$strict>;
+            runtimeBinding: z.ZodObject<{
+                runtimeAccountId: z.ZodString;
+                permissionHash: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        requirement: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            authority: z.ZodLiteral<"public">;
+            effect: z.ZodLiteral<"pure_input_computation">;
+        }, z.core.$strict>, z.ZodObject<{
+            authority: z.ZodLiteral<"public">;
+            effect: z.ZodLiteral<"unverified_write">;
+        }, z.core.$strict>, z.ZodObject<{
+            authority: z.ZodLiteral<"authentication">;
+            effect: z.ZodLiteral<"resource_verification">;
+            resourceKind: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            authority: z.ZodLiteral<"protected">;
+            effect: z.ZodEnum<{
+                resource_read: "resource_read";
+                resource_write: "resource_write";
+            }>;
+            resourceKind: z.ZodString;
+        }, z.core.$strict>], "effect">;
+        bindingHash: z.ZodString;
+        requiresConfirmation: z.ZodBoolean;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare function hashVoiceToolReviewBinding({ binding, requirement }: {
+    binding: VoiceToolBinding;
+    requirement: VoiceToolOperationRequirement;
+}): string;
+export declare const voiceOutboundCallRequestSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    expectedActiveReleaseId: z.ZodString;
+    destinationId: z.ZodString;
+    fixtureId: z.ZodString;
+    idempotencyKey: z.ZodString;
+}, z.core.$strict>;
+export type VoiceOutboundCallRequest = z.infer<typeof voiceOutboundCallRequestSchema>;
+export declare function hashVoiceOutboundRequest({ context, request }: {
+    context: VoiceHumanCommandContext;
+    request: VoiceOutboundCallRequest;
+}): string;
+export declare const voiceSettingsUpdateRequestSchema: z.ZodObject<{
+    expectedRevision: z.ZodNumber;
+    limits: z.ZodObject<{
+        maxConcurrentCalls: z.ZodNumber;
+        maxDailyCallAttempts: z.ZodNumber;
+        maxDailyOutboundAttemptsPerPerson: z.ZodNumber;
+        maxCallDurationSeconds: z.ZodNumber;
+        maxDailyInboundAttemptsPerNumber: z.ZodNumber;
+        maxConcurrentInboundCallsPerNumber: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const voiceViewerUsageSchema: z.ZodObject<{
+    policyRevision: z.ZodNumber;
+    limits: z.ZodObject<{
+        maxConcurrentCalls: z.ZodNumber;
+        maxDailyCallAttempts: z.ZodNumber;
+        maxDailyOutboundAttemptsPerPerson: z.ZodNumber;
+        maxDailyInboundAttemptsPerNumber: z.ZodDefault<z.ZodNumber>;
+        maxConcurrentInboundCallsPerNumber: z.ZodDefault<z.ZodNumber>;
+        maxCallDurationSeconds: z.ZodNumber;
+    }, z.core.$strict>;
+    utcDay: z.ZodISODate;
+    resetsAt: z.ZodISODateTime;
+    activeReservations: z.ZodNumber;
+    admittedAttempts: z.ZodNumber;
+    personalOutboundAttempts: z.ZodNumber;
+}, z.core.$strict>;
+export declare const voiceInboundAdmissionEvidenceSchema: z.ZodObject<{
+    tenantId: z.ZodString;
+    environmentId: z.ZodString;
+    agentId: z.ZodString;
+    twilioAccountSid: z.ZodString;
+    twilioCallSid: z.ZodString;
+    ownedNumberId: z.ZodString;
+    routeId: z.ZodString;
+    routeRevision: z.ZodNumber;
+    checkedAt: z.ZodISODateTime;
+    currentPreAnswerIdentityVerified: z.ZodLiteral<true>;
+}, z.core.$strict>;
+export type VoiceInboundAdmissionEvidence = z.infer<typeof voiceInboundAdmissionEvidenceSchema>;
+export declare const voiceCallResponseSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    agentId: z.ZodString;
+    releaseId: z.ZodString;
+    revision: z.ZodNumber;
+    state: z.ZodEnum<{
+        ACTIVE: "ACTIVE";
+        FAILED: "FAILED";
+        RESERVED: "RESERVED";
+        DISPATCHING: "DISPATCHING";
+        CONNECTING: "CONNECTING";
+        ENDING: "ENDING";
+        COMPLETED: "COMPLETED";
+        UNKNOWN: "UNKNOWN";
+        CANCELLING: "CANCELLING";
+        CANCELLED: "CANCELLED";
+    }>;
+}, z.core.$strict>;
+export type VoiceCallResponse = z.infer<typeof voiceCallResponseSchema>;
+export declare const voiceDispatchCallCommandSchema: z.ZodObject<{
+    tenantId: z.ZodString;
+    environmentId: z.ZodString;
+    sessionId: z.ZodString;
+    expectedRevision: z.ZodNumber;
+    operationId: z.ZodString;
+}, z.core.$strict>;
+export type VoiceDispatchCallCommand = z.infer<typeof voiceDispatchCallCommandSchema>;
+export declare const voiceToolDispatchRequestSchema: z.ZodObject<{
+    toolAlias: z.ZodString;
+    providerDeliveryId: z.ZodString;
+    arguments: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+}, z.core.$strict>;
+export type VoiceToolDispatchRequest = z.infer<typeof voiceToolDispatchRequestSchema>;
+export declare const voiceCompletionCommandSchema: z.ZodObject<{
+    tenantId: z.ZodString;
+    environmentId: z.ZodString;
+    sessionId: z.ZodString;
+    deliveryReceiptId: z.ZodString;
+    deliveryBodyHash: z.ZodString;
+    event: z.ZodObject<{
+        eventId: z.ZodString;
+        logicalIdentity: z.ZodObject<{
+            sessionId: z.ZodString;
+            kind: z.ZodLiteral<"CALL_COMPLETED">;
+        }, z.core.$strict>;
+        providerDeliveryIds: z.ZodArray<z.ZodString>;
+        evidenceStatus: z.ZodEnum<{
+            CONTRADICTORY: "CONTRADICTORY";
+            PENDING: "PENDING";
+            CONFIRMED: "CONFIRMED";
+        }>;
+        persistedAt: z.ZodISODateTime;
+        providerConversationId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type VoiceCompletionCommand = z.infer<typeof voiceCompletionCommandSchema>;
+export declare const voiceCompletionResponseSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    runId: z.ZodString;
+    completionEventId: z.ZodString;
+    duplicate: z.ZodBoolean;
+    writebackStatus: z.ZodEnum<{
+        FAILED: "FAILED";
+        RECONCILIATION_REQUIRED: "RECONCILIATION_REQUIRED";
+        COMPLETE: "COMPLETE";
+        PENDING: "PENDING";
+    }>;
+}, z.core.$strict>;
+export type VoiceCompletionResponse = z.infer<typeof voiceCompletionResponseSchema>;
+export declare const voiceAgentControlRequestSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    expectedRevision: z.ZodNumber;
+    action: z.ZodEnum<{
+        ENABLE: "ENABLE";
+        CLOSE_ADMISSION: "CLOSE_ADMISSION";
+        KILL: "KILL";
+    }>;
+    idempotencyKey: z.ZodString;
+}, z.core.$strict>;
+export declare const voiceAgentDisableRequestSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    expectedRevision: z.ZodNumber;
+}, z.core.$strict>;
+export declare const voiceAgentDisableResponseSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    revision: z.ZodNumber;
+    desiredEnabled: z.ZodLiteral<false>;
+    activeReleaseId: z.ZodNullable<z.ZodString>;
+    publicationPaused: z.ZodBoolean;
+    maintenancePaused: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const voiceEnvironmentControlRequestSchema: z.ZodObject<{
+    expectedRevision: z.ZodNumber;
+    action: z.ZodEnum<{
+        ENABLE: "ENABLE";
+        CLOSE_ADMISSION: "CLOSE_ADMISSION";
+        KILL: "KILL";
+    }>;
+    idempotencyKey: z.ZodString;
+}, z.core.$strict>;
+export declare const voiceCallCancelRequestSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    expectedRevision: z.ZodNumber;
+    idempotencyKey: z.ZodString;
+}, z.core.$strict>;
+export declare const voiceInboundRouteUpdateRequestSchema: z.ZodObject<{
+    ownedNumberId: z.ZodString;
+    agentId: z.ZodString;
+    expectedRevision: z.ZodNullable<z.ZodNumber>;
+    enabled: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const voiceDependencyMaintenanceRequestSchema: z.ZodObject<{
+    managedFunctionId: z.ZodString;
+    expectedRevision: z.ZodNullable<z.ZodNumber>;
+    action: z.ZodEnum<{
+        BEGIN: "BEGIN";
+        END: "END";
+    }>;
+    idempotencyKey: z.ZodString;
+}, z.core.$strict>;
+export interface VoiceAuthoringService {
+    validatePublication(input: {
+        context: VoiceHumanCommandContext;
+        request: z.infer<typeof voicePublishValidationRequestSchema>;
+    }): Promise<VoiceResult<z.infer<typeof voicePublishValidationResponseSchema>>>;
+    saveDraft(input: {
+        context: VoiceHumanCommandContext;
+        request: z.infer<typeof voiceDraftSaveRequestSchema>;
+    }): Promise<VoiceResult<VoiceDraft>>;
+    captureSkill(input: {
+        context: VoiceHumanCommandContext;
+        request: z.infer<typeof voiceSkillCaptureRequestSchema>;
+    }): Promise<VoiceResult<VoiceDraft>>;
+    publish(input: {
+        context: VoiceHumanCommandContext;
+        request: VoicePublishRequest;
+    }): Promise<VoiceResult<VoicePublicationResponse>>;
+}
+export interface VoiceCallService {
+    admitOutbound(input: {
+        context: VoiceHumanCommandContext;
+        request: VoiceOutboundCallRequest;
+    }): Promise<VoiceResult<VoiceCallResponse>>;
+    admitInbound(input: {
+        evidence: VoiceInboundAdmissionEvidence;
+    }): Promise<VoiceResult<VoiceCallResponse>>;
+    dispatchCall(input: VoiceDispatchCallCommand): Promise<VoiceResult<VoiceCallResponse>>;
+    complete(input: VoiceCompletionCommand): Promise<VoiceResult<VoiceCompletionResponse>>;
+}
+export declare const voiceDraftReadResponseSchema: z.ZodObject<{
+    tenantId: z.ZodString;
+    environmentId: z.ZodString;
+    agentId: z.ZodString;
+    revision: z.ZodNumber;
+    definition: z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        id: z.ZodString;
+        permissions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<{
+                user: "user";
+                group: "group";
+            }>;
+            id: z.ZodString;
+            role: z.ZodEnum<{
+                owner: "owner";
+                editor: "editor";
+                invoker: "invoker";
+                outputs_viewer: "outputs_viewer";
+            }>;
+        }, z.core.$strip>>>;
+        mode: z.ZodLiteral<"voice">;
+        model: z.ZodObject<{
+            provider: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strict>;
+        systemPrompt: z.ZodString;
+        skills: z.ZodPipe<z.ZodDefault<z.ZodArray<z.ZodString>>, z.ZodTransform<string[], string[]>>;
+        voice: z.ZodPipe<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"1">;
+            voice: z.ZodString;
+            language: z.ZodString;
+            firstMessage: z.ZodString;
+            procedures: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodObject<{
+                key: z.ZodString;
+                name: z.ZodString;
+                instructions: z.ZodString;
+                activationDescription: z.ZodString;
+                source: z.ZodObject<{
+                    skillId: z.ZodString;
+                    contentHash: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>;
+                toolAliases: z.ZodDefault<z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<string[], string[]>>>;
+                subprocedures: z.ZodDefault<z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<string[], string[]>>>;
+            }, z.core.$strict>, z.ZodTransform<{
+                source: {
+                    skillId: string;
+                    contentHash: string;
+                };
+                key: string;
+                name: string;
+                instructions: string;
+                activationDescription: string;
+                toolAliases: string[];
+                subprocedures: string[];
+            }, {
+                key: string;
+                name: string;
+                instructions: string;
+                activationDescription: string;
+                source: {
+                    skillId: string;
+                    contentHash?: string | undefined;
+                };
+                toolAliases: string[];
+                subprocedures: string[];
+            }>>>>;
+            tools: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodObject<{
+                alias: z.ZodString;
+                description: z.ZodString;
+                managedFunction: z.ZodObject<{
+                    ref: z.ZodString;
+                    operation: z.ZodString;
+                }, z.core.$strict>;
+                inputMappings: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    argument: z.ZodString;
+                    parameter: z.ZodString;
+                }, z.core.$strict>>>;
+                outputMappings: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    field: z.ZodString;
+                    result: z.ZodString;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>, z.ZodTransform<{
+                inputMappings: {
+                    argument: string;
+                    parameter: string;
+                }[];
+                outputMappings: {
+                    field: string;
+                    result: string;
+                }[];
+                alias: string;
+                description: string;
+                managedFunction: {
+                    ref: string;
+                    operation: string;
+                };
+            }, {
+                alias: string;
+                description: string;
+                managedFunction: {
+                    ref: string;
+                    operation: string;
+                };
+                inputMappings: {
+                    argument: string;
+                    parameter: string;
+                }[];
+                outputMappings: {
+                    field: string;
+                    result: string;
+                }[];
+            }>>>>;
+        }, z.core.$strict>, z.ZodTransform<{
+            procedures: {
+                source: {
+                    skillId: string;
+                    contentHash: string;
+                };
+                key: string;
+                name: string;
+                instructions: string;
+                activationDescription: string;
+                toolAliases: string[];
+                subprocedures: string[];
+            }[];
+            tools: {
+                inputMappings: {
+                    argument: string;
+                    parameter: string;
+                }[];
+                outputMappings: {
+                    field: string;
+                    result: string;
+                }[];
+                alias: string;
+                description: string;
+                managedFunction: {
+                    ref: string;
+                    operation: string;
+                };
+            }[];
+            schemaVersion: "1";
+            voice: string;
+            language: string;
+            firstMessage: string;
+        }, {
+            schemaVersion: "1";
+            voice: string;
+            language: string;
+            firstMessage: string;
+            procedures: {
+                source: {
+                    skillId: string;
+                    contentHash: string;
+                };
+                key: string;
+                name: string;
+                instructions: string;
+                activationDescription: string;
+                toolAliases: string[];
+                subprocedures: string[];
+            }[];
+            tools: {
+                inputMappings: {
+                    argument: string;
+                    parameter: string;
+                }[];
+                outputMappings: {
+                    field: string;
+                    result: string;
+                }[];
+                alias: string;
+                description: string;
+                managedFunction: {
+                    ref: string;
+                    operation: string;
+                };
+            }[];
+        }>>;
+        isPublic: z.ZodOptional<z.ZodLiteral<false>>;
+        publicOutputs: z.ZodOptional<z.ZodLiteral<false>>;
+    }, z.core.$strict>;
+    updatedByPrincipalId: z.ZodString;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export declare const voiceDefinitionExportResponseSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    id: z.ZodString;
+    permissions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            user: "user";
+            group: "group";
+        }>;
+        id: z.ZodString;
+        role: z.ZodEnum<{
+            owner: "owner";
+            editor: "editor";
+            invoker: "invoker";
+            outputs_viewer: "outputs_viewer";
+        }>;
+    }, z.core.$strip>>>;
+    mode: z.ZodLiteral<"voice">;
+    model: z.ZodObject<{
+        provider: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strict>;
+    systemPrompt: z.ZodString;
+    skills: z.ZodPipe<z.ZodDefault<z.ZodArray<z.ZodString>>, z.ZodTransform<string[], string[]>>;
+    voice: z.ZodPipe<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1">;
+        voice: z.ZodString;
+        language: z.ZodString;
+        firstMessage: z.ZodString;
+        procedures: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodObject<{
+            key: z.ZodString;
+            name: z.ZodString;
+            instructions: z.ZodString;
+            activationDescription: z.ZodString;
+            source: z.ZodObject<{
+                skillId: z.ZodString;
+                contentHash: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            toolAliases: z.ZodDefault<z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<string[], string[]>>>;
+            subprocedures: z.ZodDefault<z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<string[], string[]>>>;
+        }, z.core.$strict>, z.ZodTransform<{
+            source: {
+                skillId: string;
+                contentHash: string;
+            };
+            key: string;
+            name: string;
+            instructions: string;
+            activationDescription: string;
+            toolAliases: string[];
+            subprocedures: string[];
+        }, {
+            key: string;
+            name: string;
+            instructions: string;
+            activationDescription: string;
+            source: {
+                skillId: string;
+                contentHash?: string | undefined;
+            };
+            toolAliases: string[];
+            subprocedures: string[];
+        }>>>>;
+        tools: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodObject<{
+            alias: z.ZodString;
+            description: z.ZodString;
+            managedFunction: z.ZodObject<{
+                ref: z.ZodString;
+                operation: z.ZodString;
+            }, z.core.$strict>;
+            inputMappings: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                argument: z.ZodString;
+                parameter: z.ZodString;
+            }, z.core.$strict>>>;
+            outputMappings: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                field: z.ZodString;
+                result: z.ZodString;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>, z.ZodTransform<{
+            inputMappings: {
+                argument: string;
+                parameter: string;
+            }[];
+            outputMappings: {
+                field: string;
+                result: string;
+            }[];
+            alias: string;
+            description: string;
+            managedFunction: {
+                ref: string;
+                operation: string;
+            };
+        }, {
+            alias: string;
+            description: string;
+            managedFunction: {
+                ref: string;
+                operation: string;
+            };
+            inputMappings: {
+                argument: string;
+                parameter: string;
+            }[];
+            outputMappings: {
+                field: string;
+                result: string;
+            }[];
+        }>>>>;
+    }, z.core.$strict>, z.ZodTransform<{
+        procedures: {
+            source: {
+                skillId: string;
+                contentHash: string;
+            };
+            key: string;
+            name: string;
+            instructions: string;
+            activationDescription: string;
+            toolAliases: string[];
+            subprocedures: string[];
+        }[];
+        tools: {
+            inputMappings: {
+                argument: string;
+                parameter: string;
+            }[];
+            outputMappings: {
+                field: string;
+                result: string;
+            }[];
+            alias: string;
+            description: string;
+            managedFunction: {
+                ref: string;
+                operation: string;
+            };
+        }[];
+        schemaVersion: "1";
+        voice: string;
+        language: string;
+        firstMessage: string;
+    }, {
+        schemaVersion: "1";
+        voice: string;
+        language: string;
+        firstMessage: string;
+        procedures: {
+            source: {
+                skillId: string;
+                contentHash: string;
+            };
+            key: string;
+            name: string;
+            instructions: string;
+            activationDescription: string;
+            toolAliases: string[];
+            subprocedures: string[];
+        }[];
+        tools: {
+            inputMappings: {
+                argument: string;
+                parameter: string;
+            }[];
+            outputMappings: {
+                field: string;
+                result: string;
+            }[];
+            alias: string;
+            description: string;
+            managedFunction: {
+                ref: string;
+                operation: string;
+            };
+        }[];
+    }>>;
+    isPublic: z.ZodOptional<z.ZodLiteral<false>>;
+    publicOutputs: z.ZodOptional<z.ZodLiteral<false>>;
+}, z.core.$strict>;
+export declare const voiceRunReadResponseSchema: z.ZodObject<{
+    callPolicy: z.ZodObject<{
+        policyRevision: z.ZodNumber;
+        admittedAt: z.ZodISODateTime;
+        setupAllowanceSeconds: z.ZodLiteral<120>;
+        maxCallDurationSeconds: z.ZodNumber;
+        providerReleaseDurationCeilingSeconds: z.ZodNumber;
+        absoluteExpiresAt: z.ZodISODateTime;
+        connectedAt: z.ZodNullable<z.ZodISODateTime>;
+        connectedDeadlineAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strict>;
+    providerReferences: z.ZodObject<{
+        provider: z.ZodLiteral<"ELEVENLABS">;
+        providerAgentId: z.ZodNullable<z.ZodString>;
+        providerConversationId: z.ZodNullable<z.ZodString>;
+        conversationBindingStatus: z.ZodEnum<{
+            MISSING: "MISSING";
+            CONTRADICTORY: "CONTRADICTORY";
+            CORROBORATED: "CORROBORATED";
+            UNVERIFIED: "UNVERIFIED";
+        }>;
+        twilioCallSid: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    authentication: z.ZodObject<{
+        outcome: z.ZodEnum<{
+            unknown: "unknown";
+            verified: "verified";
+            locked: "locked";
+            rejected: "rejected";
+            not_attempted: "not_attempted";
+        }>;
+        authorityAtRunEnd: z.ZodEnum<{
+            unknown: "unknown";
+            expired: "expired";
+            revoked: "revoked";
+            active: "active";
+        }>;
+        method: z.ZodNullable<z.ZodString>;
+        attemptedAt: z.ZodNullable<z.ZodISODateTime>;
+        verifiedAt: z.ZodNullable<z.ZodISODateTime>;
+        verifiedResource: z.ZodNullable<z.ZodObject<{
+            kind: z.ZodString;
+            id: z.ZodString;
+        }, z.core.$strict>>;
+        verifierInvocationId: z.ZodNullable<z.ZodString>;
+        observedFunctionVersionId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    toolOutcomes: z.ZodArray<z.ZodObject<{
+        toolInvocationId: z.ZodString;
+        providerToolCallId: z.ZodNullable<z.ZodString>;
+        functionInvocationId: z.ZodNullable<z.ZodString>;
+        actionIntentId: z.ZodNullable<z.ZodString>;
+        actionReceiptId: z.ZodNullable<z.ZodString>;
+        actionPhase: z.ZodNullable<z.ZodEnum<{
+            UNKNOWN: "UNKNOWN";
+            PREPARE: "PREPARE";
+            CONFIRM: "CONFIRM";
+            CANCEL: "CANCEL";
+        }>>;
+        actionResolution: z.ZodNullable<z.ZodEnum<{
+            CANCELLED: "CANCELLED";
+            COMMITTED: "COMMITTED";
+        }>>;
+        toolAlias: z.ZodString;
+        operationKind: z.ZodEnum<{
+            AUTHENTICATION: "AUTHENTICATION";
+            READ: "READ";
+            CALCULATION: "CALCULATION";
+            BUSINESS_ACTION: "BUSINESS_ACTION";
+        }>;
+        status: z.ZodEnum<{
+            FAILED: "FAILED";
+            SUCCEEDED: "SUCCEEDED";
+            UNKNOWN: "UNKNOWN";
+            CANCELLED: "CANCELLED";
+            DENIED: "DENIED";
+        }>;
+        startedAt: z.ZodISODateTime;
+        completedAt: z.ZodNullable<z.ZodISODateTime>;
+        observedFunctionVersionId: z.ZodNullable<z.ZodString>;
+        validatedArguments: z.ZodNullable<z.ZodJSONSchema>;
+        boundedResult: z.ZodNullable<z.ZodJSONSchema>;
+        sanitizedError: z.ZodNullable<z.ZodObject<{
+            code: z.ZodString;
+            message: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    transcript: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"AVAILABLE">;
+        transcriptReferenceId: z.ZodString;
+        capturedAt: z.ZodISODateTime;
+        entries: z.ZodArray<z.ZodObject<{
+            sequence: z.ZodNumber;
+            speaker: z.ZodEnum<{
+                AGENT: "AGENT";
+                CALLER: "CALLER";
+                TOOL: "TOOL";
+                SYSTEM: "SYSTEM";
+            }>;
+            text: z.ZodString;
+            startedAt: z.ZodNullable<z.ZodISODateTime>;
+            endedAt: z.ZodNullable<z.ZodISODateTime>;
+        }, z.core.$strict>>;
+        sanitizedDetail: z.ZodNull;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodEnum<{
+            MISSING: "MISSING";
+            PENDING: "PENDING";
+        }>;
+        transcriptReferenceId: z.ZodNull;
+        capturedAt: z.ZodNullable<z.ZodISODateTime>;
+        entries: z.ZodArray<z.ZodObject<{
+            sequence: z.ZodNumber;
+            speaker: z.ZodEnum<{
+                AGENT: "AGENT";
+                CALLER: "CALLER";
+                TOOL: "TOOL";
+                SYSTEM: "SYSTEM";
+            }>;
+            text: z.ZodString;
+            startedAt: z.ZodNullable<z.ZodISODateTime>;
+            endedAt: z.ZodNullable<z.ZodISODateTime>;
+        }, z.core.$strict>>;
+        sanitizedDetail: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"CONTRADICTORY">;
+        transcriptReferenceId: z.ZodNullable<z.ZodString>;
+        capturedAt: z.ZodNullable<z.ZodISODateTime>;
+        entries: z.ZodArray<z.ZodObject<{
+            sequence: z.ZodNumber;
+            speaker: z.ZodEnum<{
+                AGENT: "AGENT";
+                CALLER: "CALLER";
+                TOOL: "TOOL";
+                SYSTEM: "SYSTEM";
+            }>;
+            text: z.ZodString;
+            startedAt: z.ZodNullable<z.ZodISODateTime>;
+            endedAt: z.ZodNullable<z.ZodISODateTime>;
+        }, z.core.$strict>>;
+        sanitizedDetail: z.ZodString;
+    }, z.core.$strict>], "status">;
+    completionEvent: z.ZodNullable<z.ZodObject<{
+        eventId: z.ZodString;
+        logicalIdentity: z.ZodObject<{
+            sessionId: z.ZodString;
+            kind: z.ZodLiteral<"CALL_COMPLETED">;
+        }, z.core.$strict>;
+        providerDeliveryIds: z.ZodArray<z.ZodString>;
+        evidenceStatus: z.ZodEnum<{
+            CONTRADICTORY: "CONTRADICTORY";
+            PENDING: "PENDING";
+            CONFIRMED: "CONFIRMED";
+        }>;
+        persistedAt: z.ZodISODateTime;
+        providerConversationId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    missingEvidence: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            TRANSCRIPT: "TRANSCRIPT";
+            COMPLETION_EVENT: "COMPLETION_EVENT";
+            RECORDING: "RECORDING";
+            AUTHENTICATION: "AUTHENTICATION";
+            RUNTIME_IDENTITY: "RUNTIME_IDENTITY";
+            ENABLING_OPERATOR: "ENABLING_OPERATOR";
+            PROVIDER_BINDING: "PROVIDER_BINDING";
+            CALL_TIMING: "CALL_TIMING";
+            ACTION_RESULT: "ACTION_RESULT";
+            WRITEBACK: "WRITEBACK";
+        }>;
+        status: z.ZodEnum<{
+            MISSING: "MISSING";
+            CONTRADICTORY: "CONTRADICTORY";
+            PENDING: "PENDING";
+        }>;
+        firstObservedAt: z.ZodISODateTime;
+        sanitizedDetail: z.ZodString;
+    }, z.core.$strict>>;
+    costFacts: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        source: z.ZodEnum<{
+            PROVIDER: "PROVIDER";
+            TWILIO: "TWILIO";
+            ATLAS: "ATLAS";
+        }>;
+        category: z.ZodEnum<{
+            TOOL: "TOOL";
+            CALL: "CALL";
+            MODEL: "MODEL";
+            TELEPHONY: "TELEPHONY";
+        }>;
+        currency: z.ZodString;
+        amountMinorUnits: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        source: z.ZodLiteral<"PROVIDER">;
+        category: z.ZodLiteral<"CALL">;
+        unit: z.ZodLiteral<"CREDITS">;
+        amount: z.ZodNumber;
+    }, z.core.$strict>]>>;
+    latencyFacts: z.ZodArray<z.ZodObject<{
+        source: z.ZodEnum<{
+            PROVIDER: "PROVIDER";
+            TWILIO: "TWILIO";
+            ATLAS: "ATLAS";
+        }>;
+        metric: z.ZodEnum<{
+            FIRST_AUDIBLE_RESPONSE: "FIRST_AUDIBLE_RESPONSE";
+            FIRST_SUBSTANTIVE_RESPONSE: "FIRST_SUBSTANTIVE_RESPONSE";
+            TOOL_INVOCATION: "TOOL_INVOCATION";
+            COMPLETION_PROCESSING: "COMPLETION_PROCESSING";
+        }>;
+        milliseconds: z.ZodNumber;
+    }, z.core.$strict>>;
+    terminationReason: z.ZodEnum<{
+        UNKNOWN: "UNKNOWN";
+        REMOTE_HANGUP: "REMOTE_HANGUP";
+        ATLAS_CANCELLED: "ATLAS_CANCELLED";
+        DURATION_LIMIT: "DURATION_LIMIT";
+        PROVIDER_FAILURE: "PROVIDER_FAILURE";
+        TELEPHONY_FAILURE: "TELEPHONY_FAILURE";
+        ADMISSION_SHUTDOWN: "ADMISSION_SHUTDOWN";
+    }>;
+    schemaVersion: z.ZodLiteral<"1">;
+    scope: z.ZodObject<{
+        tenantId: z.ZodString;
+        environmentId: z.ZodString;
+        agentId: z.ZodString;
+    }, z.core.$strict>;
+    runId: z.ZodString;
+    sessionId: z.ZodString;
+    agentVersionId: z.ZodString;
+    releaseId: z.ZodString;
+    direction: z.ZodEnum<{
+        INBOUND: "INBOUND";
+        OUTBOUND: "OUTBOUND";
+    }>;
+    callerIdentity: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        direction: z.ZodLiteral<"INBOUND">;
+        initiatingStaffPrincipalId: z.ZodNull;
+        phoneCaller: z.ZodObject<{
+            classification: z.ZodLiteral<"UNAUTHENTICATED_PHONE_CALLER">;
+            callerId: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        direction: z.ZodLiteral<"OUTBOUND">;
+        initiatingStaffPrincipalId: z.ZodString;
+        phoneCaller: z.ZodObject<{
+            classification: z.ZodLiteral<"REGISTERED_DESTINATION">;
+            destinationId: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>], "direction">;
+    runtimeAccountId: z.ZodString;
+    enablingOperatorPrincipalId: z.ZodNullable<z.ZodString>;
+    admittedAt: z.ZodISODateTime;
+    startedAt: z.ZodNullable<z.ZodISODateTime>;
+    endedAt: z.ZodNullable<z.ZodISODateTime>;
+    durationSeconds: z.ZodNullable<z.ZodNumber>;
+    telephoneOutcome: z.ZodEnum<{
+        FAILED: "FAILED";
+        COMPLETED: "COMPLETED";
+        UNKNOWN: "UNKNOWN";
+        CANCELLED: "CANCELLED";
+    }>;
+    businessOutcome: z.ZodEnum<{
+        FAILED: "FAILED";
+        SUCCEEDED: "SUCCEEDED";
+        UNKNOWN: "UNKNOWN";
+        PARTIAL: "PARTIAL";
+        NOT_REQUESTED: "NOT_REQUESTED";
+    }>;
+    writebackStatus: z.ZodEnum<{
+        FAILED: "FAILED";
+        RECONCILIATION_REQUIRED: "RECONCILIATION_REQUIRED";
+        COMPLETE: "COMPLETE";
+        PENDING: "PENDING";
+    }>;
+    evidenceStatus: z.ZodEnum<{
+        COMPLETE: "COMPLETE";
+        INCOMPLETE: "INCOMPLETE";
+        CONTRADICTORY: "CONTRADICTORY";
+        PENDING: "PENDING";
+    }>;
+    syntheticResource: z.ZodObject<{
+        candidate: z.ZodNullable<z.ZodObject<{
+            fixtureId: z.ZodString;
+            syntheticResource: z.ZodObject<{
+                kind: z.ZodString;
+                id: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        verifiedResource: z.ZodNullable<z.ZodObject<{
+            kind: z.ZodString;
+            id: z.ZodString;
+        }, z.core.$strict>>;
+        verificationStatus: z.ZodEnum<{
+            FAILED: "FAILED";
+            UNKNOWN: "UNKNOWN";
+            VERIFIED: "VERIFIED";
+            NOT_VERIFIED: "NOT_VERIFIED";
+            LOCKED: "LOCKED";
+            EXPIRED: "EXPIRED";
+            REVOKED: "REVOKED";
+        }>;
+    }, z.core.$strict>;
+    retention: z.ZodObject<{
+        policy: z.ZodLiteral<"UNLIMITED">;
+        ageBasedExpiry: z.ZodLiteral<false>;
+        appliesTo: z.ZodTuple<[z.ZodLiteral<"TRANSCRIPT">, z.ZodLiteral<"TOOL_EVIDENCE">, z.ZodLiteral<"COMPLETION_EVENT">, z.ZodLiteral<"RUN_METADATA">, z.ZodLiteral<"RECORDING">], null>;
+    }, z.core.$strict>;
+    recording: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"DISABLED">;
+        enabled: z.ZodLiteral<false>;
+        providerRetention: z.ZodNull;
+        sanitizedDetail: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"PENDING">;
+        enabled: z.ZodLiteral<true>;
+        providerRetention: z.ZodObject<{
+            policy: z.ZodLiteral<"UNLIMITED">;
+            providerRetentionDays: z.ZodLiteral<-1>;
+            evidenceRef: z.ZodString;
+        }, z.core.$strict>;
+        sanitizedDetail: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"AVAILABLE">;
+        enabled: z.ZodLiteral<true>;
+        providerRetention: z.ZodObject<{
+            policy: z.ZodLiteral<"UNLIMITED">;
+            providerRetentionDays: z.ZodLiteral<-1>;
+            evidenceRef: z.ZodString;
+        }, z.core.$strict>;
+        sanitizedDetail: z.ZodNull;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"UNAVAILABLE">;
+        enabled: z.ZodLiteral<true>;
+        providerRetention: z.ZodObject<{
+            policy: z.ZodLiteral<"UNLIMITED">;
+            providerRetentionDays: z.ZodLiteral<-1>;
+            evidenceRef: z.ZodString;
+        }, z.core.$strict>;
+        sanitizedDetail: z.ZodString;
+    }, z.core.$strict>], "status">;
+}, z.core.$strict>;