@dakkitor/api-contracts 1.1.153 → 1.4.0

package/dist/worker-source-identity-conflicts/worker-source-identity-conflicts.schemas.d.ts

@@ -0,0 +1,453 @@
+import { z } from 'zod';
+export declare const WorkerSourceIdentityConflictStatusSchema: z.ZodEnum<["OPEN", "RESOLVED", "INVALIDATED", "EXPIRED"]>;
+export declare const WorkerSourceIdentityConflictContextSchema: z.ZodEnum<["SINGLE", "BATCH", "IMPORT"]>;
+export declare const WorkerSourceIdentityConflictPhoneMaskSchema: z.ZodString;
+export declare const WorkerSourceIdentityReviewAdjustmentSchema: z.ZodObject<{
+    caseId: z.ZodString;
+    retainedPhoneMasks: z.ZodArray<z.ZodString, "many">;
+    excludedPhoneMasks: z.ZodArray<z.ZodString, "many">;
+}, "strict", z.ZodTypeAny, {
+    caseId: string;
+    retainedPhoneMasks: string[];
+    excludedPhoneMasks: string[];
+}, {
+    caseId: string;
+    retainedPhoneMasks: string[];
+    excludedPhoneMasks: string[];
+}>;
+export declare const WorkerSourceIdentityConflictPhoneEvidenceSchema: z.ZodObject<{
+    phoneMasked: z.ZodString;
+    curatedWorker: z.ZodObject<{
+        id: z.ZodString;
+        firstName: z.ZodString;
+        lastName: z.ZodNullable<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        firstName: string;
+        lastName: string | null;
+    }, {
+        id: string;
+        firstName: string;
+        lastName: string | null;
+    }>;
+    contactedAt: z.ZodString;
+    channel: z.ZodEnum<["PHONE", "WHATSAPP"]>;
+    outcome: z.ZodString;
+    qualifyingContactCount: z.ZodNumber;
+    revealIds: z.ZodArray<z.ZodString, "many">;
+    contactEventIds: z.ZodArray<z.ZodString, "many">;
+    callIds: z.ZodArray<z.ZodString, "many">;
+}, "strict", z.ZodTypeAny, {
+    phoneMasked: string;
+    curatedWorker: {
+        id: string;
+        firstName: string;
+        lastName: string | null;
+    };
+    contactedAt: string;
+    channel: "PHONE" | "WHATSAPP";
+    outcome: string;
+    qualifyingContactCount: number;
+    revealIds: string[];
+    contactEventIds: string[];
+    callIds: string[];
+}, {
+    phoneMasked: string;
+    curatedWorker: {
+        id: string;
+        firstName: string;
+        lastName: string | null;
+    };
+    contactedAt: string;
+    channel: "PHONE" | "WHATSAPP";
+    outcome: string;
+    qualifyingContactCount: number;
+    revealIds: string[];
+    contactEventIds: string[];
+    callIds: string[];
+}>;
+export declare const WorkerSourceIdentityConflictReferenceSchema: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodEnum<["OPEN", "RESOLVED", "INVALIDATED", "EXPIRED"]>;
+    reviewUrl: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    status: "OPEN" | "RESOLVED" | "INVALIDATED" | "EXPIRED";
+    id: string;
+    reviewUrl: string;
+}, {
+    status: "OPEN" | "RESOLVED" | "INVALIDATED" | "EXPIRED";
+    id: string;
+    reviewUrl: string;
+}>;
+export declare const WorkerSourceIdentityConflictSummarySchema: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodEnum<["OPEN", "RESOLVED", "INVALIDATED", "EXPIRED"]>;
+    reviewUrl: z.ZodString;
+} & {
+    context: z.ZodEnum<["SINGLE", "BATCH", "IMPORT"]>;
+    contextId: z.ZodNullable<z.ZodString>;
+    rowNumber: z.ZodNullable<z.ZodNumber>;
+    submittedWorkerName: z.ZodString;
+    submittedPhoneMasks: z.ZodArray<z.ZodString, "many">;
+    candidateCuratedWorkerIds: z.ZodArray<z.ZodString, "many">;
+    selectedCuratedWorkerId: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodString;
+    expiresAt: z.ZodString;
+    reviewedAt: z.ZodNullable<z.ZodString>;
+    terminalAt: z.ZodNullable<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    status: "OPEN" | "RESOLVED" | "INVALIDATED" | "EXPIRED";
+    id: string;
+    reviewUrl: string;
+    context: "SINGLE" | "BATCH" | "IMPORT";
+    contextId: string | null;
+    rowNumber: number | null;
+    submittedWorkerName: string;
+    submittedPhoneMasks: string[];
+    candidateCuratedWorkerIds: string[];
+    selectedCuratedWorkerId: string | null;
+    createdAt: string;
+    expiresAt: string;
+    reviewedAt: string | null;
+    terminalAt: string | null;
+}, {
+    status: "OPEN" | "RESOLVED" | "INVALIDATED" | "EXPIRED";
+    id: string;
+    reviewUrl: string;
+    context: "SINGLE" | "BATCH" | "IMPORT";
+    contextId: string | null;
+    rowNumber: number | null;
+    submittedWorkerName: string;
+    submittedPhoneMasks: string[];
+    candidateCuratedWorkerIds: string[];
+    selectedCuratedWorkerId: string | null;
+    createdAt: string;
+    expiresAt: string;
+    reviewedAt: string | null;
+    terminalAt: string | null;
+}>;
+export declare const WorkerSourceIdentityConflictDetailSchema: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodEnum<["OPEN", "RESOLVED", "INVALIDATED", "EXPIRED"]>;
+    reviewUrl: z.ZodString;
+} & {
+    context: z.ZodEnum<["SINGLE", "BATCH", "IMPORT"]>;
+    contextId: z.ZodNullable<z.ZodString>;
+    rowNumber: z.ZodNullable<z.ZodNumber>;
+    submittedWorkerName: z.ZodString;
+    submittedPhoneMasks: z.ZodArray<z.ZodString, "many">;
+    candidateCuratedWorkerIds: z.ZodArray<z.ZodString, "many">;
+    selectedCuratedWorkerId: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodString;
+    expiresAt: z.ZodString;
+    reviewedAt: z.ZodNullable<z.ZodString>;
+    terminalAt: z.ZodNullable<z.ZodString>;
+} & {
+    candidateEvidence: z.ZodArray<z.ZodObject<{
+        phoneMasked: z.ZodString;
+        curatedWorker: z.ZodObject<{
+            id: z.ZodString;
+            firstName: z.ZodString;
+            lastName: z.ZodNullable<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            id: string;
+            firstName: string;
+            lastName: string | null;
+        }, {
+            id: string;
+            firstName: string;
+            lastName: string | null;
+        }>;
+        contactedAt: z.ZodString;
+        channel: z.ZodEnum<["PHONE", "WHATSAPP"]>;
+        outcome: z.ZodString;
+        qualifyingContactCount: z.ZodNumber;
+        revealIds: z.ZodArray<z.ZodString, "many">;
+        contactEventIds: z.ZodArray<z.ZodString, "many">;
+        callIds: z.ZodArray<z.ZodString, "many">;
+    }, "strict", z.ZodTypeAny, {
+        phoneMasked: string;
+        curatedWorker: {
+            id: string;
+            firstName: string;
+            lastName: string | null;
+        };
+        contactedAt: string;
+        channel: "PHONE" | "WHATSAPP";
+        outcome: string;
+        qualifyingContactCount: number;
+        revealIds: string[];
+        contactEventIds: string[];
+        callIds: string[];
+    }, {
+        phoneMasked: string;
+        curatedWorker: {
+            id: string;
+            firstName: string;
+            lastName: string | null;
+        };
+        contactedAt: string;
+        channel: "PHONE" | "WHATSAPP";
+        outcome: string;
+        qualifyingContactCount: number;
+        revealIds: string[];
+        contactEventIds: string[];
+        callIds: string[];
+    }>, "many">;
+    retainedPhoneMasks: z.ZodArray<z.ZodString, "many">;
+    excludedPhoneMasks: z.ZodArray<z.ZodString, "many">;
+}, "strict", z.ZodTypeAny, {
+    retainedPhoneMasks: string[];
+    status: "OPEN" | "RESOLVED" | "INVALIDATED" | "EXPIRED";
+    excludedPhoneMasks: string[];
+    id: string;
+    reviewUrl: string;
+    context: "SINGLE" | "BATCH" | "IMPORT";
+    contextId: string | null;
+    rowNumber: number | null;
+    submittedWorkerName: string;
+    submittedPhoneMasks: string[];
+    candidateCuratedWorkerIds: string[];
+    selectedCuratedWorkerId: string | null;
+    createdAt: string;
+    expiresAt: string;
+    reviewedAt: string | null;
+    terminalAt: string | null;
+    candidateEvidence: {
+        phoneMasked: string;
+        curatedWorker: {
+            id: string;
+            firstName: string;
+            lastName: string | null;
+        };
+        contactedAt: string;
+        channel: "PHONE" | "WHATSAPP";
+        outcome: string;
+        qualifyingContactCount: number;
+        revealIds: string[];
+        contactEventIds: string[];
+        callIds: string[];
+    }[];
+}, {
+    retainedPhoneMasks: string[];
+    status: "OPEN" | "RESOLVED" | "INVALIDATED" | "EXPIRED";
+    excludedPhoneMasks: string[];
+    id: string;
+    reviewUrl: string;
+    context: "SINGLE" | "BATCH" | "IMPORT";
+    contextId: string | null;
+    rowNumber: number | null;
+    submittedWorkerName: string;
+    submittedPhoneMasks: string[];
+    candidateCuratedWorkerIds: string[];
+    selectedCuratedWorkerId: string | null;
+    createdAt: string;
+    expiresAt: string;
+    reviewedAt: string | null;
+    terminalAt: string | null;
+    candidateEvidence: {
+        phoneMasked: string;
+        curatedWorker: {
+            id: string;
+            firstName: string;
+            lastName: string | null;
+        };
+        contactedAt: string;
+        channel: "PHONE" | "WHATSAPP";
+        outcome: string;
+        qualifyingContactCount: number;
+        revealIds: string[];
+        contactEventIds: string[];
+        callIds: string[];
+    }[];
+}>;
+export declare const ResolveWorkerSourceIdentityConflictBodySchema: z.ZodObject<{
+    selectedCuratedWorkerId: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    selectedCuratedWorkerId: string;
+}, {
+    selectedCuratedWorkerId: string;
+}>;
+export declare const ListWorkerSourceIdentityConflictsQuerySchema: z.ZodObject<{
+    page: z.ZodDefault<z.ZodNumber>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    status: z.ZodDefault<z.ZodEnum<["OPEN", "RESOLVED", "INVALIDATED", "EXPIRED"]>>;
+    context: z.ZodOptional<z.ZodEnum<["SINGLE", "BATCH", "IMPORT"]>>;
+    contextId: z.ZodOptional<z.ZodString>;
+    search: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    status: "OPEN" | "RESOLVED" | "INVALIDATED" | "EXPIRED";
+    page: number;
+    limit: number;
+    context?: "SINGLE" | "BATCH" | "IMPORT" | undefined;
+    contextId?: string | undefined;
+    search?: string | undefined;
+}, {
+    status?: "OPEN" | "RESOLVED" | "INVALIDATED" | "EXPIRED" | undefined;
+    context?: "SINGLE" | "BATCH" | "IMPORT" | undefined;
+    contextId?: string | undefined;
+    page?: number | undefined;
+    limit?: number | undefined;
+    search?: string | undefined;
+}>;
+export declare const WorkerSourceIdentityConflictListResponseSchema: z.ZodObject<{
+    cases: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        status: z.ZodEnum<["OPEN", "RESOLVED", "INVALIDATED", "EXPIRED"]>;
+        reviewUrl: z.ZodString;
+    } & {
+        context: z.ZodEnum<["SINGLE", "BATCH", "IMPORT"]>;
+        contextId: z.ZodNullable<z.ZodString>;
+        rowNumber: z.ZodNullable<z.ZodNumber>;
+        submittedWorkerName: z.ZodString;
+        submittedPhoneMasks: z.ZodArray<z.ZodString, "many">;
+        candidateCuratedWorkerIds: z.ZodArray<z.ZodString, "many">;
+        selectedCuratedWorkerId: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodString;
+        expiresAt: z.ZodString;
+        reviewedAt: z.ZodNullable<z.ZodString>;
+        terminalAt: z.ZodNullable<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        status: "OPEN" | "RESOLVED" | "INVALIDATED" | "EXPIRED";
+        id: string;
+        reviewUrl: string;
+        context: "SINGLE" | "BATCH" | "IMPORT";
+        contextId: string | null;
+        rowNumber: number | null;
+        submittedWorkerName: string;
+        submittedPhoneMasks: string[];
+        candidateCuratedWorkerIds: string[];
+        selectedCuratedWorkerId: string | null;
+        createdAt: string;
+        expiresAt: string;
+        reviewedAt: string | null;
+        terminalAt: string | null;
+    }, {
+        status: "OPEN" | "RESOLVED" | "INVALIDATED" | "EXPIRED";
+        id: string;
+        reviewUrl: string;
+        context: "SINGLE" | "BATCH" | "IMPORT";
+        contextId: string | null;
+        rowNumber: number | null;
+        submittedWorkerName: string;
+        submittedPhoneMasks: string[];
+        candidateCuratedWorkerIds: string[];
+        selectedCuratedWorkerId: string | null;
+        createdAt: string;
+        expiresAt: string;
+        reviewedAt: string | null;
+        terminalAt: string | null;
+    }>, "many">;
+    totalCount: z.ZodNumber;
+    totalPages: z.ZodNumber;
+    page: z.ZodNumber;
+    limit: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    page: number;
+    limit: number;
+    cases: {
+        status: "OPEN" | "RESOLVED" | "INVALIDATED" | "EXPIRED";
+        id: string;
+        reviewUrl: string;
+        context: "SINGLE" | "BATCH" | "IMPORT";
+        contextId: string | null;
+        rowNumber: number | null;
+        submittedWorkerName: string;
+        submittedPhoneMasks: string[];
+        candidateCuratedWorkerIds: string[];
+        selectedCuratedWorkerId: string | null;
+        createdAt: string;
+        expiresAt: string;
+        reviewedAt: string | null;
+        terminalAt: string | null;
+    }[];
+    totalCount: number;
+    totalPages: number;
+}, {
+    page: number;
+    limit: number;
+    cases: {
+        status: "OPEN" | "RESOLVED" | "INVALIDATED" | "EXPIRED";
+        id: string;
+        reviewUrl: string;
+        context: "SINGLE" | "BATCH" | "IMPORT";
+        contextId: string | null;
+        rowNumber: number | null;
+        submittedWorkerName: string;
+        submittedPhoneMasks: string[];
+        candidateCuratedWorkerIds: string[];
+        selectedCuratedWorkerId: string | null;
+        createdAt: string;
+        expiresAt: string;
+        reviewedAt: string | null;
+        terminalAt: string | null;
+    }[];
+    totalCount: number;
+    totalPages: number;
+}>;
+export declare const WorkerSourceIdentityConflictRequiredResponseSchema: z.ZodObject<{
+    message: z.ZodString;
+    code: z.ZodLiteral<"WORKER_IDENTITY_CONFLICT">;
+    statusCode: z.ZodLiteral<409>;
+    details: z.ZodObject<{
+        identityConflict: z.ZodObject<{
+            id: z.ZodString;
+            status: z.ZodEnum<["OPEN", "RESOLVED", "INVALIDATED", "EXPIRED"]>;
+            reviewUrl: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            status: "OPEN" | "RESOLVED" | "INVALIDATED" | "EXPIRED";
+            id: string;
+            reviewUrl: string;
+        }, {
+            status: "OPEN" | "RESOLVED" | "INVALIDATED" | "EXPIRED";
+            id: string;
+            reviewUrl: string;
+        }>;
+    }, "strict", z.ZodTypeAny, {
+        identityConflict: {
+            status: "OPEN" | "RESOLVED" | "INVALIDATED" | "EXPIRED";
+            id: string;
+            reviewUrl: string;
+        };
+    }, {
+        identityConflict: {
+            status: "OPEN" | "RESOLVED" | "INVALIDATED" | "EXPIRED";
+            id: string;
+            reviewUrl: string;
+        };
+    }>;
+}, "strict", z.ZodTypeAny, {
+    code: "WORKER_IDENTITY_CONFLICT";
+    message: string;
+    statusCode: 409;
+    details: {
+        identityConflict: {
+            status: "OPEN" | "RESOLVED" | "INVALIDATED" | "EXPIRED";
+            id: string;
+            reviewUrl: string;
+        };
+    };
+}, {
+    code: "WORKER_IDENTITY_CONFLICT";
+    message: string;
+    statusCode: 409;
+    details: {
+        identityConflict: {
+            status: "OPEN" | "RESOLVED" | "INVALIDATED" | "EXPIRED";
+            id: string;
+            reviewUrl: string;
+        };
+    };
+}>;
+export type WorkerSourceIdentityConflictStatus = z.infer<typeof WorkerSourceIdentityConflictStatusSchema>;
+export type WorkerSourceIdentityConflictContext = z.infer<typeof WorkerSourceIdentityConflictContextSchema>;
+export type WorkerSourceIdentityConflictPhoneEvidence = z.infer<typeof WorkerSourceIdentityConflictPhoneEvidenceSchema>;
+export type WorkerSourceIdentityReviewAdjustment = z.infer<typeof WorkerSourceIdentityReviewAdjustmentSchema>;
+export type WorkerSourceIdentityConflictReference = z.infer<typeof WorkerSourceIdentityConflictReferenceSchema>;
+export type WorkerSourceIdentityConflictSummary = z.infer<typeof WorkerSourceIdentityConflictSummarySchema>;
+export type WorkerSourceIdentityConflictDetail = z.infer<typeof WorkerSourceIdentityConflictDetailSchema>;
+export type ResolveWorkerSourceIdentityConflictBody = z.infer<typeof ResolveWorkerSourceIdentityConflictBodySchema>;
+export type ListWorkerSourceIdentityConflictsQuery = z.infer<typeof ListWorkerSourceIdentityConflictsQuerySchema>;
+export type WorkerSourceIdentityConflictListResponse = z.infer<typeof WorkerSourceIdentityConflictListResponseSchema>;
+export type WorkerSourceIdentityConflictRequiredResponse = z.infer<typeof WorkerSourceIdentityConflictRequiredResponseSchema>;
+//# sourceMappingURL=worker-source-identity-conflicts.schemas.d.ts.map

package/dist/worker-source-identity-conflicts/worker-source-identity-conflicts.schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-source-identity-conflicts.schemas.d.ts","sourceRoot":"","sources":["../../contracts/worker-source-identity-conflicts/worker-source-identity-conflicts.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,wCAAwC,2DAKnD,CAAC;AAEH,eAAO,MAAM,yCAAyC,0CAIpD,CAAC;AAEH,eAAO,MAAM,2CAA2C,aAE1B,CAAC;AAE/B,eAAO,MAAM,0CAA0C;;;;;;;;;;;;EAM5C,CAAC;AAEZ,eAAO,MAAM,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkBjD,CAAC;AAEZ,eAAO,MAAM,2CAA2C;;;;;;;;;;;;EAM7C,CAAC;AAEZ,eAAO,MAAM,yCAAyC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAezC,CAAC;AAEd,eAAO,MAAM,wCAAwC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOxC,CAAC;AAEd,eAAO,MAAM,6CAA6C;;;;;;EAI/C,CAAC;AAEZ,eAAO,MAAM,4CAA4C;;;;;;;;;;;;;;;;;;;;;EAS9C,CAAC;AAEZ,eAAO,MAAM,8CAA8C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQhD,CAAC;AAEZ,eAAO,MAAM,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWpD,CAAC;AAEZ,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CACtD,OAAO,wCAAwC,CAChD,CAAC;AACF,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CACvD,OAAO,yCAAyC,CACjD,CAAC;AACF,MAAM,MAAM,yCAAyC,GAAG,CAAC,CAAC,KAAK,CAC7D,OAAO,+CAA+C,CACvD,CAAC;AACF,MAAM,MAAM,oCAAoC,GAAG,CAAC,CAAC,KAAK,CACxD,OAAO,0CAA0C,CAClD,CAAC;AACF,MAAM,MAAM,qCAAqC,GAAG,CAAC,CAAC,KAAK,CACzD,OAAO,2CAA2C,CACnD,CAAC;AACF,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CACvD,OAAO,yCAAyC,CACjD,CAAC;AACF,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CACtD,OAAO,wCAAwC,CAChD,CAAC;AACF,MAAM,MAAM,uCAAuC,GAAG,CAAC,CAAC,KAAK,CAC3D,OAAO,6CAA6C,CACrD,CAAC;AACF,MAAM,MAAM,sCAAsC,GAAG,CAAC,CAAC,KAAK,CAC1D,OAAO,4CAA4C,CACpD,CAAC;AACF,MAAM,MAAM,wCAAwC,GAAG,CAAC,CAAC,KAAK,CAC5D,OAAO,8CAA8C,CACtD,CAAC;AACF,MAAM,MAAM,4CAA4C,GAAG,CAAC,CAAC,KAAK,CAChE,OAAO,kDAAkD,CAC1D,CAAC"}

package/dist/worker-source-identity-conflicts/worker-source-identity-conflicts.schemas.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerSourceIdentityConflictRequiredResponseSchema = exports.WorkerSourceIdentityConflictListResponseSchema = exports.ListWorkerSourceIdentityConflictsQuerySchema = exports.ResolveWorkerSourceIdentityConflictBodySchema = exports.WorkerSourceIdentityConflictDetailSchema = exports.WorkerSourceIdentityConflictSummarySchema = exports.WorkerSourceIdentityConflictReferenceSchema = exports.WorkerSourceIdentityConflictPhoneEvidenceSchema = exports.WorkerSourceIdentityReviewAdjustmentSchema = exports.WorkerSourceIdentityConflictPhoneMaskSchema = exports.WorkerSourceIdentityConflictContextSchema = exports.WorkerSourceIdentityConflictStatusSchema = void 0;
+const zod_1 = require("zod");
+exports.WorkerSourceIdentityConflictStatusSchema = zod_1.z.enum([
+    'OPEN',
+    'RESOLVED',
+    'INVALIDATED',
+    'EXPIRED',
+]);
+exports.WorkerSourceIdentityConflictContextSchema = zod_1.z.enum([
+    'SINGLE',
+    'BATCH',
+    'IMPORT',
+]);
+exports.WorkerSourceIdentityConflictPhoneMaskSchema = zod_1.z
+    .string()
+    .regex(/^\+\d{2}••••\d{4}$/);
+exports.WorkerSourceIdentityReviewAdjustmentSchema = zod_1.z
+    .object({
+    caseId: zod_1.z.string().uuid(),
+    retainedPhoneMasks: zod_1.z.array(exports.WorkerSourceIdentityConflictPhoneMaskSchema),
+    excludedPhoneMasks: zod_1.z.array(exports.WorkerSourceIdentityConflictPhoneMaskSchema),
+})
+    .strict();
+exports.WorkerSourceIdentityConflictPhoneEvidenceSchema = zod_1.z
+    .object({
+    phoneMasked: exports.WorkerSourceIdentityConflictPhoneMaskSchema,
+    curatedWorker: zod_1.z
+        .object({
+        id: zod_1.z.string().uuid(),
+        firstName: zod_1.z.string().max(255),
+        lastName: zod_1.z.string().max(255).nullable(),
+    })
+        .strict(),
+    contactedAt: zod_1.z.string().datetime(),
+    channel: zod_1.z.enum(['PHONE', 'WHATSAPP']),
+    outcome: zod_1.z.string().min(1).max(255),
+    qualifyingContactCount: zod_1.z.number().int().positive(),
+    revealIds: zod_1.z.array(zod_1.z.string().uuid()),
+    contactEventIds: zod_1.z.array(zod_1.z.string().uuid()),
+    callIds: zod_1.z.array(zod_1.z.string().uuid()),
+})
+    .strict();
+exports.WorkerSourceIdentityConflictReferenceSchema = zod_1.z
+    .object({
+    id: zod_1.z.string().uuid(),
+    status: exports.WorkerSourceIdentityConflictStatusSchema,
+    reviewUrl: zod_1.z.string().startsWith('/workers/identity-matches'),
+})
+    .strict();
+exports.WorkerSourceIdentityConflictSummarySchema = exports.WorkerSourceIdentityConflictReferenceSchema.extend({
+    context: exports.WorkerSourceIdentityConflictContextSchema,
+    contextId: zod_1.z.string().uuid().nullable(),
+    rowNumber: zod_1.z.number().int().min(0).nullable(),
+    submittedWorkerName: zod_1.z.string(),
+    submittedPhoneMasks: zod_1.z
+        .array(exports.WorkerSourceIdentityConflictPhoneMaskSchema)
+        .min(1),
+    candidateCuratedWorkerIds: zod_1.z.array(zod_1.z.string().uuid()).min(2),
+    selectedCuratedWorkerId: zod_1.z.string().uuid().nullable(),
+    createdAt: zod_1.z.string().datetime(),
+    expiresAt: zod_1.z.string().datetime(),
+    reviewedAt: zod_1.z.string().datetime().nullable(),
+    terminalAt: zod_1.z.string().datetime().nullable(),
+}).strict();
+exports.WorkerSourceIdentityConflictDetailSchema = exports.WorkerSourceIdentityConflictSummarySchema.extend({
+    candidateEvidence: zod_1.z
+        .array(exports.WorkerSourceIdentityConflictPhoneEvidenceSchema)
+        .min(2),
+    retainedPhoneMasks: zod_1.z.array(exports.WorkerSourceIdentityConflictPhoneMaskSchema),
+    excludedPhoneMasks: zod_1.z.array(exports.WorkerSourceIdentityConflictPhoneMaskSchema),
+}).strict();
+exports.ResolveWorkerSourceIdentityConflictBodySchema = zod_1.z
+    .object({
+    selectedCuratedWorkerId: zod_1.z.string().uuid(),
+})
+    .strict();
+exports.ListWorkerSourceIdentityConflictsQuerySchema = zod_1.z
+    .object({
+    page: zod_1.z.coerce.number().int().min(1).default(1),
+    limit: zod_1.z.coerce.number().int().min(1).max(200).default(50),
+    status: exports.WorkerSourceIdentityConflictStatusSchema.default('OPEN'),
+    context: exports.WorkerSourceIdentityConflictContextSchema.optional(),
+    contextId: zod_1.z.string().uuid().optional(),
+    search: zod_1.z.string().trim().min(1).optional(),
+})
+    .strict();
+exports.WorkerSourceIdentityConflictListResponseSchema = zod_1.z
+    .object({
+    cases: zod_1.z.array(exports.WorkerSourceIdentityConflictSummarySchema),
+    totalCount: zod_1.z.number().int().min(0),
+    totalPages: zod_1.z.number().int().min(0),
+    page: zod_1.z.number().int().min(1),
+    limit: zod_1.z.number().int().min(1).max(200),
+})
+    .strict();
+exports.WorkerSourceIdentityConflictRequiredResponseSchema = zod_1.z
+    .object({
+    message: zod_1.z.string(),
+    code: zod_1.z.literal('WORKER_IDENTITY_CONFLICT'),
+    statusCode: zod_1.z.literal(409),
+    details: zod_1.z
+        .object({
+        identityConflict: exports.WorkerSourceIdentityConflictReferenceSchema,
+    })
+        .strict(),
+})
+    .strict();

package/dist/workers/do-not-contact.contract.d.ts

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+/** Max days a worker may be held out of rotation by a single DNC window. */
+export declare const DNC_MAX_DAYS = 30;
+/**
+ * Max accepted by the DNC write endpoints. The standard DNC form remains
+ * capped at DNC_MAX_DAYS; this wider bound exists for the explicit
+ * NOT_INTERESTED bridge's 90-day choice.
+ */
+export declare const DNC_WRITE_MAX_DAYS = 90;
+/**
+ * Reasons that mean "do not offer this worker work right now" — a subset of
+ * DeclineReason. NO_ANSWER (retry) and WRONG_NUMBER (phone flag) are outreach
+ * outcomes, NOT do-not-contact states, so they are excluded here.
+ */
+export declare const DoNotContactReasonSchema: z.ZodEnum<["ALREADY_WORKING", "NOT_INTERESTED", "OUT_OF_COUNTRY", "OTHER"]>;
+export type DoNotContactReason = z.infer<typeof DoNotContactReasonSchema>;
+export declare const DNC_REASON_LABELS: Record<DoNotContactReason, string>;
+/** Body for setting/extending a DNC window. */
+export declare const SetDoNotContactSchema: z.ZodEffects<z.ZodObject<{
+    reason: z.ZodEnum<["ALREADY_WORKING", "NOT_INTERESTED", "OUT_OF_COUNTRY", "OTHER"]>;
+    note: z.ZodOptional<z.ZodString>;
+    days: z.ZodOptional<z.ZodNumber>;
+    indefinite: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    reason: "NOT_INTERESTED" | "ALREADY_WORKING" | "OUT_OF_COUNTRY" | "OTHER";
+    note?: string | undefined;
+    days?: number | undefined;
+    indefinite?: boolean | undefined;
+}, {
+    reason: "NOT_INTERESTED" | "ALREADY_WORKING" | "OUT_OF_COUNTRY" | "OTHER";
+    note?: string | undefined;
+    days?: number | undefined;
+    indefinite?: boolean | undefined;
+}>, {
+    reason: "NOT_INTERESTED" | "ALREADY_WORKING" | "OUT_OF_COUNTRY" | "OTHER";
+    note?: string | undefined;
+    days?: number | undefined;
+    indefinite?: boolean | undefined;
+}, {
+    reason: "NOT_INTERESTED" | "ALREADY_WORKING" | "OUT_OF_COUNTRY" | "OTHER";
+    note?: string | undefined;
+    days?: number | undefined;
+    indefinite?: boolean | undefined;
+}>;
+export type SetDoNotContact = z.infer<typeof SetDoNotContactSchema>;
+//# sourceMappingURL=do-not-contact.contract.d.ts.map

package/dist/workers/do-not-contact.contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"do-not-contact.contract.d.ts","sourceRoot":"","sources":["../../contracts/workers/do-not-contact.contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,4EAA4E;AAC5E,eAAO,MAAM,YAAY,KAAK,CAAC;AAE/B;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,KAAK,CAAC;AAErC;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,6EAKnC,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,kBAAkB,EAAE,MAAM,CAKhE,CAAC;AAEF,+CAA+C;AAC/C,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;EAa/B,CAAC;AACJ,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC"}

package/dist/workers/do-not-contact.contract.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetDoNotContactSchema = exports.DNC_REASON_LABELS = exports.DoNotContactReasonSchema = exports.DNC_WRITE_MAX_DAYS = exports.DNC_MAX_DAYS = void 0;
+const zod_1 = require("zod");
+/** Max days a worker may be held out of rotation by a single DNC window. */
+exports.DNC_MAX_DAYS = 30;
+/**
+ * Max accepted by the DNC write endpoints. The standard DNC form remains
+ * capped at DNC_MAX_DAYS; this wider bound exists for the explicit
+ * NOT_INTERESTED bridge's 90-day choice.
+ */
+exports.DNC_WRITE_MAX_DAYS = 90;
+/**
+ * Reasons that mean "do not offer this worker work right now" — a subset of
+ * DeclineReason. NO_ANSWER (retry) and WRONG_NUMBER (phone flag) are outreach
+ * outcomes, NOT do-not-contact states, so they are excluded here.
+ */
+exports.DoNotContactReasonSchema = zod_1.z.enum([
+    'ALREADY_WORKING',
+    'NOT_INTERESTED',
+    'OUT_OF_COUNTRY',
+    'OTHER',
+]);
+exports.DNC_REASON_LABELS = {
+    ALREADY_WORKING: 'Working',
+    NOT_INTERESTED: 'Not interested',
+    OUT_OF_COUNTRY: 'Out of country',
+    OTHER: 'Other',
+};
+/** Body for setting/extending a DNC window. */
+exports.SetDoNotContactSchema = zod_1.z
+    .object({
+    reason: exports.DoNotContactReasonSchema,
+    note: zod_1.z.string().trim().min(1).optional(),
+    days: zod_1.z.number().int().min(1).max(exports.DNC_WRITE_MAX_DAYS).optional(),
+    indefinite: zod_1.z.boolean().optional(),
+})
+    .refine(({ days, indefinite }) => (days !== undefined) !== (indefinite === true), {
+    message: 'Specify exactly one of days or indefinite',
+    path: ['days'],
+});

package/dist/workers/do-not-contact.contract.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=do-not-contact.contract.spec.d.ts.map

package/dist/workers/do-not-contact.contract.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"do-not-contact.contract.spec.d.ts","sourceRoot":"","sources":["../../contracts/workers/do-not-contact.contract.spec.ts"],"names":[],"mappings":""}