@dakkitor/api-contracts 1.8.0 → 1.9.2

package/dist/candidate-calling/candidate-calling.contract.spec.js

@@ -0,0 +1,357 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const candidate_calling_contract_1 = require("./candidate-calling.contract");
+describe('candidate calling ring target', () => {
+    it('accepts only DESKTOP and PHONE', () => {
+        expect(candidate_calling_contract_1.CandidateCallingRingTargetSchema.parse('DESKTOP')).toBe('DESKTOP');
+        expect(candidate_calling_contract_1.CandidateCallingRingTargetSchema.parse('PHONE')).toBe('PHONE');
+        expect(candidate_calling_contract_1.CandidateCallingRingTargetSchema.safeParse('FAX').success).toBe(false);
+    });
+    it('reports the ring target on availability', () => {
+        const parsed = candidate_calling_contract_1.CandidateCallingAvailabilitySchema.parse({
+            enabled: true,
+            reason: null,
+            ringTarget: 'PHONE',
+        });
+        expect(parsed.ringTarget).toBe('PHONE');
+    });
+    it('exposes a route to change the ring target', () => {
+        expect(candidate_calling_contract_1.candidateCallingContract.setRingTarget.method).toBe('PATCH');
+        expect(candidate_calling_contract_1.candidateCallingContract.setRingTarget.path).toBe('/v2/candidate-calling-queues/ring-target');
+    });
+});
+describe('candidate calling contract', () => {
+    it('pins the application routes', () => {
+        expect(candidate_calling_contract_1.candidateCallingContract.availability).toMatchObject({
+            method: 'GET',
+            path: '/v2/candidate-calling-queues/availability',
+        });
+        expect(candidate_calling_contract_1.candidateCallingContract.createQueue).toMatchObject({
+            method: 'POST',
+            path: '/v2/jobs/:jobId/candidate-calling-queues',
+        });
+        expect(candidate_calling_contract_1.candidateCallingContract.activeQueue).toMatchObject({
+            method: 'GET',
+            path: '/v2/candidate-calling-queues/active',
+        });
+        expect(candidate_calling_contract_1.candidateCallingContract.nextCandidate).toMatchObject({
+            method: 'POST',
+            path: '/v2/candidate-calling-queues/:queueSessionId/next',
+        });
+        expect(candidate_calling_contract_1.candidateCallingContract.endCall).toMatchObject({
+            method: 'POST',
+            path: '/v2/candidate-dialpad-calls/:callId/end',
+        });
+        expect(candidate_calling_contract_1.candidateCallingContract.stopQueue).toMatchObject({
+            method: 'DELETE',
+            path: '/v2/candidate-calling-queues/:queueSessionId',
+        });
+        expect(candidate_calling_contract_1.candidateCallingContract.reviewArtifact).toMatchObject({
+            method: 'GET',
+            path: '/v2/candidate-dialpad-calls/:callId/review-artifact',
+        });
+        expect(candidate_calling_contract_1.candidateCallingContract.getCallReview).toMatchObject({
+            method: 'GET',
+            path: '/v2/candidate-dialpad-calls/:callId/review',
+        });
+        expect(candidate_calling_contract_1.candidateCallingContract.resolveProfileFact).toMatchObject({
+            method: 'POST',
+            path: '/v2/candidate-dialpad-calls/:callId/profile-facts/:field/resolve',
+        });
+    });
+    it('validates every route path parameter as a UUID', () => {
+        const uuid = '88888888-8888-4888-8888-888888888888';
+        expect('pathParams' in candidate_calling_contract_1.candidateCallingContract.availability).toBe(false);
+        expect('pathParams' in candidate_calling_contract_1.candidateCallingContract.activeQueue).toBe(false);
+        expect(candidate_calling_contract_1.candidateCallingContract.createQueue.pathParams.safeParse({ jobId: uuid })
+            .success).toBe(true);
+        expect(candidate_calling_contract_1.candidateCallingContract.createQueue.pathParams.safeParse({
+            jobId: 'not-a-uuid',
+        }).success).toBe(false);
+        expect(candidate_calling_contract_1.candidateCallingContract.nextCandidate.pathParams.safeParse({
+            queueSessionId: uuid,
+        }).success).toBe(true);
+        expect(candidate_calling_contract_1.candidateCallingContract.nextCandidate.pathParams.safeParse({
+            queueSessionId: 'not-a-uuid',
+        }).success).toBe(false);
+        expect(candidate_calling_contract_1.candidateCallingContract.endCall.pathParams.safeParse({ callId: uuid })
+            .success).toBe(true);
+        expect(candidate_calling_contract_1.candidateCallingContract.endCall.pathParams.safeParse({
+            callId: 'not-a-uuid',
+        }).success).toBe(false);
+        expect(candidate_calling_contract_1.candidateCallingContract.stopQueue.pathParams.safeParse({
+            queueSessionId: uuid,
+        }).success).toBe(true);
+        expect(candidate_calling_contract_1.candidateCallingContract.stopQueue.pathParams.safeParse({
+            queueSessionId: 'not-a-uuid',
+        }).success).toBe(false);
+        expect(candidate_calling_contract_1.candidateCallingContract.reviewArtifact.pathParams.safeParse({
+            callId: uuid,
+        }).success).toBe(true);
+        expect(candidate_calling_contract_1.candidateCallingContract.reviewArtifact.pathParams.safeParse({
+            callId: 'not-a-uuid',
+        }).success).toBe(false);
+        expect(candidate_calling_contract_1.candidateCallingContract.reviewArtifact.pathParams.safeParse({
+            callId: uuid,
+            objectKey: 'private',
+        }).success).toBe(false);
+    });
+    it('pins every route response status set', () => {
+        expect(Object.keys(candidate_calling_contract_1.candidateCallingContract.availability.responses).map(Number)).toEqual([200]);
+        expect(Object.keys(candidate_calling_contract_1.candidateCallingContract.createQueue.responses).map(Number)).toEqual([200, 403, 404, 409, 503]);
+        expect(Object.keys(candidate_calling_contract_1.candidateCallingContract.activeQueue.responses).map(Number)).toEqual([200, 403]);
+        expect(Object.keys(candidate_calling_contract_1.candidateCallingContract.nextCandidate.responses).map(Number)).toEqual([200, 403, 404, 409, 429, 503]);
+        expect(Object.keys(candidate_calling_contract_1.candidateCallingContract.endCall.responses).map(Number)).toEqual([200, 403, 404, 409]);
+        expect(Object.keys(candidate_calling_contract_1.candidateCallingContract.stopQueue.responses).map(Number)).toEqual([200, 403, 404, 409]);
+        expect(Object.keys(candidate_calling_contract_1.candidateCallingContract.reviewArtifact.responses).map(Number)).toEqual([200, 403, 404, 409, 410]);
+        expect(Object.keys(candidate_calling_contract_1.candidateCallingContract.getCallReview.responses).map(Number)).toEqual([200, 403, 404]);
+        expect(Object.keys(candidate_calling_contract_1.candidateCallingContract.resolveProfileFact.responses).map(Number)).toEqual([200, 403, 404, 409]);
+    });
+    it('uses strict end intent and complete managed states', () => {
+        expect(candidate_calling_contract_1.candidateCallingContract.endCall.body.safeParse({
+            continueWithNext: true,
+            extra: true,
+        }).success).toBe(false);
+        expect(candidate_calling_contract_1.CandidateDialpadCallStatusSchema.options).toEqual([
+            'CLAIMED',
+            'INITIATING',
+            'INITIATION_UNCERTAIN',
+            'RINGING',
+            'CONNECTED',
+            'ENDING',
+            'PROCESSING',
+            'FEEDBACK_RECORDED',
+            'NEEDS_REVIEW',
+            'INITIATION_FAILED',
+            'CANCELLED',
+        ]);
+    });
+    it('accepts only live queue, historical import, and automatic probe call sources', () => {
+        expect(candidate_calling_contract_1.CandidateDialpadCallSourceSchema.safeParse('LIVE_QUEUE').success).toBe(true);
+        expect(candidate_calling_contract_1.CandidateDialpadCallSourceSchema.safeParse('HISTORICAL_IMPORT').success).toBe(true);
+        expect(candidate_calling_contract_1.CandidateDialpadCallSourceSchema.safeParse('AUTOMATIC_PROBE').success).toBe(true);
+        expect(candidate_calling_contract_1.CandidateDialpadCallSourceSchema.safeParse('MANUAL_IMPORT').success).toBe(false);
+    });
+    it('keeps candidate and active-queue wrappers strict', () => {
+        const candidate = {
+            subjectKind: 'OWNED',
+            card: {
+                id: '77777777-7777-4777-8777-777777777777',
+                firstName: 'Ana',
+                hasTools: true,
+                hasPpe: true,
+                offerOpenness: 'OPEN',
+                createdAt: '2026-08-19T10:00:00.000Z',
+                updatedAt: '2026-08-19T10:00:00.000Z',
+                hasPhoneNumber: true,
+            },
+        };
+        expect(candidate_calling_contract_1.CandidateCallingCandidateSchema.options[0].safeParse(candidate).success).toBe(true);
+        expect(candidate_calling_contract_1.CandidateCallingCandidateSchema.options[0].safeParse({
+            ...candidate,
+            extra: true,
+        }).success).toBe(false);
+        expect(candidate_calling_contract_1.candidateCallingContract.activeQueue.responses[200].safeParse({
+            queue: null,
+            extra: true,
+        }).success).toBe(false);
+    });
+    it('does not expose provider or artifact secrets', () => {
+        const candidate = candidate_calling_contract_1.CandidateCallingCandidateSchema.parse({
+            subjectKind: 'OWNED',
+            card: {
+                id: '77777777-7777-4777-8777-777777777777',
+                firstName: 'Ana',
+                hasTools: true,
+                hasPpe: true,
+                offerOpenness: 'OPEN',
+                createdAt: '2026-08-19T10:00:00.000Z',
+                updatedAt: '2026-08-19T10:00:00.000Z',
+                hasPhoneNumber: true,
+                phone: '+441234567890',
+                phoneNumbers: [{ phoneNumber: '+441234567890' }],
+            },
+        });
+        expect(candidate.card).not.toHaveProperty('phone');
+        expect(candidate.card).not.toHaveProperty('phoneNumbers');
+        const parsed = candidate_calling_contract_1.CandidateCallingQueueViewSchema.parse({
+            id: '55555555-5555-4555-8555-555555555555',
+            jobId: '66666666-6666-4666-8666-666666666666',
+            status: 'PAUSED',
+            pauseReason: 'AGENT_ENDED',
+            eligibleCount: 0,
+            sandbox: { enabled: true, maskedDestination: '******1234' },
+            currentCall: null,
+            recentCalls: [],
+            retryAt: null,
+            createdAt: '2026-08-19T10:00:00.000Z',
+            updatedAt: '2026-08-19T10:00:00.000Z',
+        });
+        expect(parsed).not.toHaveProperty('dialpadToken');
+        expect(parsed).not.toHaveProperty('recordingUrl');
+        expect(parsed).not.toHaveProperty('transcript');
+    });
+    it('keeps the on-demand review response strict and private by shape', () => {
+        const response = {
+            url: 'https://private.example.test/signed-review',
+            expiresAt: '2026-08-19T12:05:00.000Z',
+        };
+        expect(candidate_calling_contract_1.CandidateCallReviewArtifactResponseSchema.parse(response)).toEqual(response);
+        expect(candidate_calling_contract_1.CandidateCallReviewArtifactResponseSchema.safeParse({
+            ...response,
+            objectKey: 'candidate-calls/private/recording',
+        }).success).toBe(false);
+        expect(candidate_calling_contract_1.CandidateCallReviewArtifactResponseSchema.safeParse({
+            ...response,
+            transcript: 'private transcript',
+        }).success).toBe(false);
+        expect(candidate_calling_contract_1.CandidateCallReviewArtifactResponseSchema.safeParse({
+            ...response,
+            modelOutput: { outcome: 'INTERESTED' },
+        }).success).toBe(false);
+    });
+    it('models the complete profile fact and typed analysis review results', () => {
+        const response = {
+            workerState: { result: { kind: 'ACTIVELY_LOOKING' } },
+            jobs: [{ jobId: '11111111-1111-4111-8111-111111111111' }],
+            profileFacts: [
+                'APPLIED',
+                'CONFLICT',
+                'PENDING',
+                'FAILED',
+                'OVERRIDDEN',
+                'ALREADY_AGREES',
+                'PENDING_REVIEW',
+                'SUPERSEDED',
+            ].map((status) => ({
+                field: 'englishLevel',
+                value: 'ADVANCED',
+                status,
+                agentValue: 'BASIC',
+                evidence: ['She said her English is very good'],
+                evidenceReferences: [
+                    {
+                        quote: 'She said her English is very good',
+                        turnId: null,
+                        startMs: null,
+                        endMs: null,
+                    },
+                ],
+            })),
+            referral: null,
+            callback: null,
+            reviewReason: null,
+            employmentObservation: {
+                status: 'WORKING',
+                elapsedDuration: { value: 2, unit: 'WEEK' },
+                confidence: 0.92,
+                evidence: ['She has worked there for two weeks'],
+            },
+            phoneAssessment: {
+                result: 'CONFIRMED_WORKER',
+                confidence: 0.97,
+                evidence: ['The worker confirmed their identity'],
+            },
+        };
+        expect(candidate_calling_contract_1.CandidateCallReviewResponseSchema.parse(response)).toEqual(response);
+        const legacyProfileFactResponse = {
+            ...response,
+            profileFacts: response.profileFacts.map(({ evidenceReferences: _evidenceReferences, ...fact }) => fact),
+        };
+        expect(candidate_calling_contract_1.CandidateCallReviewResponseSchema.parse(legacyProfileFactResponse)).toEqual(legacyProfileFactResponse);
+        expect(candidate_calling_contract_1.CandidateCallProfileFactStatusSchema.safeParse('SUPERSEDED').success).toBe(true);
+        expect(candidate_calling_contract_1.CandidateCallReviewResponseSchema.safeParse({
+            ...response,
+            extra: true,
+        }).success).toBe(false);
+        expect(candidate_calling_contract_1.CandidateCallReviewResponseSchema.safeParse({
+            ...response,
+            profileFacts: [{ ...response.profileFacts[0], status: 'NOT_A_STATUS' }],
+        }).success).toBe(false);
+    });
+    it('accepts only inbound and outbound Dialpad call directions', () => {
+        expect(candidate_calling_contract_1.CandidateDialpadCallDirectionSchema.parse('INBOUND')).toBe('INBOUND');
+        expect(candidate_calling_contract_1.CandidateDialpadCallDirectionSchema.parse('OUTBOUND')).toBe('OUTBOUND');
+        expect(candidate_calling_contract_1.CandidateDialpadCallDirectionSchema.safeParse('SIDEWAYS').success).toBe(false);
+    });
+    it('parses timed and legacy-normalized transcript rows and rejects invalid timings', () => {
+        const timedTranscript = {
+            outcome: 'TRANSCRIPT',
+            languages: ['en', 'ro'],
+            turns: [
+                {
+                    id: 'turn-0001',
+                    speaker: 'AGENT',
+                    text: 'Hello, this is Lorena.',
+                    startMs: 840,
+                    endMs: 2470,
+                },
+            ],
+        };
+        expect(candidate_calling_contract_1.CandidateDialpadCallTranscriptResponseSchema.parse(timedTranscript)).toEqual(timedTranscript);
+        expect(candidate_calling_contract_1.CandidateDialpadCallTranscriptResponseSchema.parse({
+            ...timedTranscript,
+            turns: [{ ...timedTranscript.turns[0], startMs: null, endMs: null }],
+        })).toBeDefined();
+        expect(() => candidate_calling_contract_1.CandidateDialpadCallTranscriptResponseSchema.parse({
+            ...timedTranscript,
+            turns: [{ ...timedTranscript.turns[0], startMs: -1 }],
+        })).toThrow();
+        expect(() => candidate_calling_contract_1.CandidateDialpadCallTranscriptResponseSchema.parse({
+            ...timedTranscript,
+            turns: [{ ...timedTranscript.turns[0], startMs: 840.5 }],
+        })).toThrow();
+    });
+    it('parses linked and unlinked evidence and rejects incomplete or reversed links', () => {
+        expect(candidate_calling_contract_1.CandidateCallReviewEvidenceSchema.parse({
+            quote: 'I can start on Monday.',
+            turnId: 'turn-0007',
+            startMs: 18200,
+            endMs: 19540,
+        })).toBeDefined();
+        expect(candidate_calling_contract_1.CandidateCallReviewEvidenceSchema.parse({
+            quote: 'I can start on Monday.',
+            turnId: null,
+            startMs: null,
+            endMs: null,
+        })).toBeDefined();
+        expect(() => candidate_calling_contract_1.CandidateCallReviewEvidenceSchema.parse({
+            quote: 'I can start on Monday.',
+            turnId: 'turn-0007',
+            startMs: null,
+            endMs: null,
+        })).toThrow();
+        expect(() => candidate_calling_contract_1.CandidateCallReviewEvidenceSchema.parse({
+            quote: 'I can start on Monday.',
+            turnId: 'turn-0007',
+            startMs: 19540,
+            endMs: 18200,
+        })).toThrow();
+    });
+    it('accepts only KEEP_AGENT or APPLY_AI as a profile-fact resolution', () => {
+        expect(candidate_calling_contract_1.ResolveProfileFactBodySchema.safeParse({ resolution: 'APPLY_AI' })
+            .success).toBe(true);
+        expect(candidate_calling_contract_1.ResolveProfileFactBodySchema.safeParse({ resolution: 'KEEP_AGENT' })
+            .success).toBe(true);
+        expect(candidate_calling_contract_1.ResolveProfileFactBodySchema.safeParse({ resolution: 'DISCARD' }).success).toBe(false);
+        expect(candidate_calling_contract_1.ResolveProfileFactBodySchema.safeParse({
+            resolution: 'APPLY_AI',
+            extra: true,
+        }).success).toBe(false);
+    });
+    it('publishes only queue identity and change time', () => {
+        const payload = {
+            queueSessionId: '55555555-5555-4555-8555-555555555555',
+            updatedAt: '2026-08-19T12:00:00.000Z',
+        };
+        expect(candidate_calling_contract_1.CandidateCallingQueueChangedSchema.parse(payload)).toEqual(payload);
+        expect(candidate_calling_contract_1.CandidateCallingQueueChangedSchema.safeParse({
+            ...payload,
+            phoneNumber: '+447700900123',
+        }).success).toBe(false);
+        expect(candidate_calling_contract_1.CandidateCallingQueueChangedSchema.safeParse({
+            ...payload,
+            transcript: 'private transcript',
+        }).success).toBe(false);
+    });
+});

package/dist/candidate-calling/candidate-dialpad-call.schemas.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+export declare const CandidateDialpadCallStatusSchema: z.ZodEnum<["CLAIMED", "INITIATING", "INITIATION_UNCERTAIN", "RINGING", "CONNECTED", "ENDING", "PROCESSING", "FEEDBACK_RECORDED", "NEEDS_REVIEW", "INITIATION_FAILED", "CANCELLED"]>;
+export type CandidateDialpadCallStatus = z.infer<typeof CandidateDialpadCallStatusSchema>;
+export declare const CandidateDialpadCallSourceSchema: z.ZodEnum<["LIVE_QUEUE", "HISTORICAL_IMPORT", "AUTOMATIC_PROBE"]>;
+export type CandidateDialpadCallSource = z.infer<typeof CandidateDialpadCallSourceSchema>;
+export declare const CandidateDialpadCallDirectionSchema: z.ZodEnum<["INBOUND", "OUTBOUND"]>;
+export type CandidateDialpadCallDirection = z.infer<typeof CandidateDialpadCallDirectionSchema>;
+export declare const CandidateContactHistoryConnectionSchema: z.ZodEnum<["CONNECTED", "NO_ANSWER", "BUSY", "INVALID_NUMBER", "FAILED"]>;
+export type CandidateContactHistoryConnection = z.infer<typeof CandidateContactHistoryConnectionSchema>;
+//# sourceMappingURL=candidate-dialpad-call.schemas.d.ts.map

package/dist/candidate-calling/candidate-dialpad-call.schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"candidate-dialpad-call.schemas.d.ts","sourceRoot":"","sources":["../../contracts/candidate-calling/candidate-dialpad-call.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,gCAAgC,qLAY3C,CAAC;AACH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAC9C,OAAO,gCAAgC,CACxC,CAAC;AAEF,eAAO,MAAM,gCAAgC,mEAI3C,CAAC;AACH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAC9C,OAAO,gCAAgC,CACxC,CAAC;AAEF,eAAO,MAAM,mCAAmC,oCAG9C,CAAC;AACH,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CACjD,OAAO,mCAAmC,CAC3C,CAAC;AAEF,eAAO,MAAM,uCAAuC,2EAMlD,CAAC;AACH,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CACrD,OAAO,uCAAuC,CAC/C,CAAC"}

package/dist/candidate-calling/candidate-dialpad-call.schemas.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CandidateContactHistoryConnectionSchema = exports.CandidateDialpadCallDirectionSchema = exports.CandidateDialpadCallSourceSchema = exports.CandidateDialpadCallStatusSchema = void 0;
+const zod_1 = require("zod");
+exports.CandidateDialpadCallStatusSchema = zod_1.z.enum([
+    'CLAIMED',
+    'INITIATING',
+    'INITIATION_UNCERTAIN',
+    'RINGING',
+    'CONNECTED',
+    'ENDING',
+    'PROCESSING',
+    'FEEDBACK_RECORDED',
+    'NEEDS_REVIEW',
+    'INITIATION_FAILED',
+    'CANCELLED',
+]);
+exports.CandidateDialpadCallSourceSchema = zod_1.z.enum([
+    'LIVE_QUEUE',
+    'HISTORICAL_IMPORT',
+    'AUTOMATIC_PROBE',
+]);
+exports.CandidateDialpadCallDirectionSchema = zod_1.z.enum([
+    'INBOUND',
+    'OUTBOUND',
+]);
+exports.CandidateContactHistoryConnectionSchema = zod_1.z.enum([
+    'CONNECTED',
+    'NO_ANSWER',
+    'BUSY',
+    'INVALID_NUMBER',
+    'FAILED',
+]);