@sequenceholdings/agent-spec 0.1.1 → 0.1.3

package/dist/voice-drafts.d.ts

@@ -0,0 +1,441 @@
+import { z } from 'zod';
+import { type VoiceAgentDefinition } from './agent-definition.js';
+import { type CapturedVoiceProcedure } from './voice-authoring.js';
+export declare const voiceDraftSchema: 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 type VoiceDraft = z.infer<typeof voiceDraftSchema>;
+export declare const voiceDraftSaveRequestSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    expectedRevision: z.ZodNullable<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>;
+}, z.core.$strict>;
+export type VoiceDraftSaveRequest = z.infer<typeof voiceDraftSaveRequestSchema>;
+export declare const voiceSkillCaptureRequestSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    expectedDraftRevision: z.ZodNumber;
+    action: z.ZodEnum<{
+        ATTACH: "ATTACH";
+        REFRESH: "REFRESH";
+    }>;
+    skillId: z.ZodString;
+    procedureKey: z.ZodString;
+    activationDescription: z.ZodString;
+    toolAliases: z.ZodArray<z.ZodString>;
+    subprocedures: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type VoiceSkillCaptureRequest = z.infer<typeof voiceSkillCaptureRequestSchema>;
+export declare const voiceSkillSourceStatusSchema: 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">;
+export type VoiceSkillSourceStatus = z.infer<typeof voiceSkillSourceStatusSchema>;
+export declare const voiceResolvedSkillSourceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    access: z.ZodLiteral<"ALLOWED">;
+    skillId: z.ZodString;
+    name: z.ZodString;
+    instructions: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    access: z.ZodLiteral<"MISSING">;
+    skillId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    access: z.ZodLiteral<"FORBIDDEN">;
+    skillId: z.ZodString;
+}, z.core.$strict>], "access">;
+export type VoiceResolvedSkillSource = z.infer<typeof voiceResolvedSkillSourceSchema>;
+export declare function assessVoiceSkillSource({ captured, source }: {
+    captured: CapturedVoiceProcedure;
+    source: VoiceResolvedSkillSource;
+}): VoiceSkillSourceStatus;
+export declare function captureVoiceSkill({ definition, request, source }: {
+    definition: VoiceAgentDefinition;
+    request: VoiceSkillCaptureRequest;
+    source: VoiceResolvedSkillSource;
+}): VoiceAgentDefinition;
+export declare const voiceDefinitionExportRequestSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"DRAFT">;
+        expectedRevision: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"VERSION">;
+        agentVersionId: z.ZodString;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>;

package/dist/voice-drafts.js

@@ -0,0 +1,75 @@
+import { z } from 'zod';
+import { voiceAgentDefinitionSchema } from './agent-definition.js';
+import { capturedVoiceProcedureSchema, hashVoiceSkillContent } from './voice-authoring.js';
+import { voiceAgentScopeSchema, voiceHashSchema, voiceIdSchema, voiceLocalKeySchema, voiceRevisionSchema, voiceTimestampSchema } from './voice-common.js';
+export const voiceDraftSchema = voiceAgentScopeSchema.extend({
+    revision: voiceRevisionSchema,
+    definition: voiceAgentDefinitionSchema,
+    updatedByPrincipalId: voiceIdSchema,
+    updatedAt: voiceTimestampSchema,
+}).refine((draft) => draft.agentId === draft.definition.id, { path: ['definition', 'id'], message: 'Draft Agent identity mismatch' });
+export const voiceDraftSaveRequestSchema = z.strictObject({
+    agentId: voiceIdSchema,
+    expectedRevision: voiceRevisionSchema.nullable(),
+    definition: voiceAgentDefinitionSchema,
+}).refine((request) => request.agentId === request.definition.id, { path: ['definition', 'id'], message: 'Draft Agent identity mismatch' });
+const procedureReferencesSchema = z.array(voiceLocalKeySchema).max(64)
+    .refine((keys) => new Set(keys).size === keys.length, 'Duplicate procedure reference');
+export const voiceSkillCaptureRequestSchema = z.strictObject({
+    agentId: voiceIdSchema,
+    expectedDraftRevision: voiceRevisionSchema,
+    action: z.enum(['ATTACH', 'REFRESH']),
+    skillId: voiceIdSchema,
+    procedureKey: voiceLocalKeySchema,
+    activationDescription: z.string().trim().max(4_000),
+    toolAliases: procedureReferencesSchema,
+    subprocedures: procedureReferencesSchema,
+});
+export const voiceSkillSourceStatusSchema = z.discriminatedUnion('status', [
+    z.strictObject({ status: z.literal('CURRENT'), skillId: voiceIdSchema, capturedContentHash: voiceHashSchema, currentContentHash: voiceHashSchema })
+        .refine((source) => source.capturedContentHash === source.currentContentHash, 'Current source hash must match capture'),
+    z.strictObject({ status: z.literal('CHANGED'), skillId: voiceIdSchema, capturedContentHash: voiceHashSchema, currentContentHash: voiceHashSchema })
+        .refine((source) => source.capturedContentHash !== source.currentContentHash, 'Changed source hash must differ from capture'),
+    z.strictObject({ status: z.literal('MISSING'), skillId: voiceIdSchema, capturedContentHash: voiceHashSchema }),
+    z.strictObject({ status: z.literal('FORBIDDEN'), skillId: voiceIdSchema, capturedContentHash: voiceHashSchema }),
+]);
+export const voiceResolvedSkillSourceSchema = z.discriminatedUnion('access', [
+    z.strictObject({ access: z.literal('ALLOWED'), skillId: voiceIdSchema,
+        name: z.string().trim().min(1).max(200), instructions: z.string().min(1).max(100_000) }),
+    z.strictObject({ access: z.literal('MISSING'), skillId: voiceIdSchema }),
+    z.strictObject({ access: z.literal('FORBIDDEN'), skillId: voiceIdSchema }),
+]);
+export function assessVoiceSkillSource({ captured, source }) {
+    if (captured.source.skillId !== source.skillId)
+        throw new Error('Skill source identity mismatch');
+    const common = { skillId: source.skillId, capturedContentHash: captured.source.contentHash };
+    if (source.access !== 'ALLOWED')
+        return { ...common, status: source.access };
+    const currentContentHash = hashVoiceSkillContent(source);
+    return { ...common, currentContentHash,
+        status: currentContentHash === captured.source.contentHash ? 'CURRENT' : 'CHANGED' };
+}
+export function captureVoiceSkill({ definition, request, source }) {
+    if (request.agentId !== definition.id || source.skillId !== request.skillId)
+        throw new Error('Capture identity mismatch');
+    if (source.access !== 'ALLOWED')
+        throw new Error(`Skill source ${source.access.toLowerCase()}`);
+    const existing = definition.voice.procedures.find((procedure) => procedure.key === request.procedureKey);
+    if ((request.action === 'ATTACH' && existing !== undefined) ||
+        (request.action === 'REFRESH' && existing?.source.skillId !== source.skillId)) {
+        throw new Error('Capture target conflict');
+    }
+    const captured = capturedVoiceProcedureSchema.parse({ key: request.procedureKey,
+        name: source.name, instructions: source.instructions, source: { skillId: source.skillId },
+        activationDescription: request.activationDescription, toolAliases: request.toolAliases, subprocedures: request.subprocedures });
+    const procedures = [...definition.voice.procedures.filter((item) => item.key !== captured.key), captured];
+    return voiceAgentDefinitionSchema.parse({ ...definition,
+        skills: procedures.map((item) => item.source.skillId), voice: { ...definition.voice, procedures } });
+}
+export const voiceDefinitionExportRequestSchema = z.strictObject({
+    agentId: voiceIdSchema,
+    source: z.discriminatedUnion('kind', [
+        z.strictObject({ kind: z.literal('DRAFT'), expectedRevision: voiceRevisionSchema }),
+        z.strictObject({ kind: z.literal('VERSION'), agentVersionId: voiceIdSchema }),
+    ]),
+});

package/dist/voice-grant.d.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+export declare const voiceCallGrantSchema: z.ZodObject<{
+    purpose: z.ZodLiteral<"VOICE_TOOL_INGRESS">;
+    subject: z.ZodObject<{
+        tenantId: z.ZodString;
+        environmentId: z.ZodString;
+        agentId: z.ZodString;
+        sessionId: z.ZodString;
+        releaseId: z.ZodString;
+    }, z.core.$strict>;
+    tokenHash: z.ZodString;
+    runtimeAccountId: z.ZodString;
+    twilioCallSid: z.ZodString;
+    revocationGeneration: z.ZodNumber;
+    issuedAt: z.ZodISODateTime;
+    expiresAt: z.ZodISODateTime;
+    revokedAt: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strict>;
+export type VoiceCallGrant = z.infer<typeof voiceCallGrantSchema>;

package/dist/voice-grant.js

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { voiceCallSubjectSchema } from './voice-authority.js';
+import { voiceHashSchema, voiceIdSchema, voiceRevisionSchema, voiceTimestampSchema } from './voice-common.js';
+export const voiceCallGrantSchema = z.strictObject({
+    purpose: z.literal('VOICE_TOOL_INGRESS'),
+    subject: voiceCallSubjectSchema,
+    tokenHash: voiceHashSchema,
+    runtimeAccountId: voiceIdSchema,
+    twilioCallSid: voiceIdSchema,
+    revocationGeneration: voiceRevisionSchema,
+    issuedAt: voiceTimestampSchema,
+    expiresAt: voiceTimestampSchema,
+    revokedAt: voiceTimestampSchema.nullable(),
+}).superRefine((grant, context) => {
+    if (Date.parse(grant.expiresAt) <= Date.parse(grant.issuedAt)) {
+        context.addIssue({ code: 'custom', path: ['expiresAt'], message: 'Grant expiry must follow issue time' });
+    }
+    if (grant.revokedAt !== null && Date.parse(grant.revokedAt) < Date.parse(grant.issuedAt)) {
+        context.addIssue({ code: 'custom', path: ['revokedAt'], message: 'Revocation cannot precede issue time' });
+    }
+});

package/dist/voice-lifecycle-control.d.ts

@@ -0,0 +1,130 @@
+import { z } from 'zod';
+import { voiceAgentScopeSchema } from './voice-common.js';
+export declare const voicePublicationPauseSchema: z.ZodObject<{
+    tenantId: z.ZodString;
+    environmentId: z.ZodString;
+    agentId: z.ZodString;
+    publicationOperationId: z.ZodString;
+    status: z.ZodEnum<{
+        ACTIVE: "ACTIVE";
+        RELEASED: "RELEASED";
+    }>;
+    revision: z.ZodNumber;
+    claimedAt: z.ZodISODateTime;
+    releasedAt: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strict>;
+export type VoicePublicationPause = z.infer<typeof voicePublicationPauseSchema>;
+type PauseClaimResult = {
+    ok: true;
+    pause: VoicePublicationPause;
+    changed: boolean;
+} | {
+    ok: false;
+    reason: 'OWNED_BY_ANOTHER_OPERATION' | 'SCOPE_MISMATCH';
+};
+export declare function claimVoicePublicationPause({ current, agentScope, publicationOperationId, claimedAt, }: {
+    current: VoicePublicationPause | null;
+    agentScope: z.infer<typeof voiceAgentScopeSchema>;
+    publicationOperationId: string;
+    claimedAt: string;
+}): PauseClaimResult;
+type PauseReleaseResult = {
+    ok: true;
+    pause: VoicePublicationPause;
+    changed: boolean;
+} | {
+    ok: false;
+    reason: 'OWNED_BY_ANOTHER_OPERATION';
+};
+export declare function releaseVoicePublicationPause({ current, publicationOperationId, releasedAt, }: {
+    current: VoicePublicationPause;
+    publicationOperationId: string;
+    releasedAt: string;
+}): PauseReleaseResult;
+export declare const voiceDependencyReferenceSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"MANAGED_FUNCTION">;
+    managedFunctionId: z.ZodString;
+    observedVersionId: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type VoiceDependencyReference = z.infer<typeof voiceDependencyReferenceSchema>;
+export declare const voiceDependencyMaintenanceTargetSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"ENVIRONMENT">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"DEPENDENCIES">;
+    dependencies: z.ZodArray<z.ZodObject<{
+        kind: z.ZodLiteral<"MANAGED_FUNCTION">;
+        managedFunctionId: z.ZodString;
+        observedVersionId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    affectedAgentIds: z.ZodArray<z.ZodString>;
+}, z.core.$strict>], "kind">;
+export type VoiceDependencyMaintenanceTarget = z.infer<typeof voiceDependencyMaintenanceTargetSchema>;
+export declare const voiceDependencyMaintenanceFenceSchema: z.ZodObject<{
+    tenantId: z.ZodString;
+    environmentId: z.ZodString;
+    fenceId: z.ZodString;
+    target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"ENVIRONMENT">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"DEPENDENCIES">;
+        dependencies: z.ZodArray<z.ZodObject<{
+            kind: z.ZodLiteral<"MANAGED_FUNCTION">;
+            managedFunctionId: z.ZodString;
+            observedVersionId: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+        affectedAgentIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>], "kind">;
+    ownerPrincipalId: z.ZodString;
+    state: z.ZodEnum<{
+        RECONCILIATION_REQUIRED: "RECONCILIATION_REQUIRED";
+        DRAINING: "DRAINING";
+        MAINTENANCE: "MAINTENANCE";
+        VERIFYING: "VERIFYING";
+        REPUBLICATION_REQUIRED: "REPUBLICATION_REQUIRED";
+        RELEASED: "RELEASED";
+    }>;
+    revision: z.ZodNumber;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type VoiceDependencyMaintenanceFence = z.infer<typeof voiceDependencyMaintenanceFenceSchema>;
+export declare const voiceAdmissionControlInputSchema: z.ZodObject<{
+    environmentEnabled: z.ZodBoolean;
+    agentEnabled: z.ZodBoolean;
+    routeEnabled: z.ZodBoolean;
+    runtimeAccountEnabled: z.ZodBoolean;
+    releaseReady: z.ZodBoolean;
+    publicationPause: z.ZodNullable<z.ZodObject<{
+        tenantId: z.ZodString;
+        environmentId: z.ZodString;
+        agentId: z.ZodString;
+        publicationOperationId: z.ZodString;
+        status: z.ZodEnum<{
+            ACTIVE: "ACTIVE";
+            RELEASED: "RELEASED";
+        }>;
+        revision: z.ZodNumber;
+        claimedAt: z.ZodISODateTime;
+        releasedAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strict>>;
+    dependencyMaintenanceBlocked: z.ZodBoolean;
+}, z.core.$strict>;
+export type VoiceAdmissionControlInput = z.infer<typeof voiceAdmissionControlInputSchema>;
+export declare const voiceAdmissionControlReasonSchema: z.ZodEnum<{
+    ENVIRONMENT_DISABLED: "ENVIRONMENT_DISABLED";
+    AGENT_DISABLED: "AGENT_DISABLED";
+    ROUTE_DISABLED: "ROUTE_DISABLED";
+    RUNTIME_ACCOUNT_DISABLED: "RUNTIME_ACCOUNT_DISABLED";
+    RELEASE_NOT_READY: "RELEASE_NOT_READY";
+    PUBLICATION_PAUSED: "PUBLICATION_PAUSED";
+    DEPENDENCY_MAINTENANCE: "DEPENDENCY_MAINTENANCE";
+}>;
+export type VoiceAdmissionControlReason = z.infer<typeof voiceAdmissionControlReasonSchema>;
+export type VoiceAdmissionControlEvaluation = {
+    admitted: true;
+} | {
+    admitted: false;
+    reason: VoiceAdmissionControlReason;
+};
+export declare function evaluateVoiceAdmissionControl(input: VoiceAdmissionControlInput): VoiceAdmissionControlEvaluation;
+export {};