@propertysimple/client 0.1.0

package/contracts/src/directory-execution.d.ts

@@ -0,0 +1,320 @@
+import { z } from 'zod';
+/** Separately provisioned authority. A recommendation policy never implicitly permits execution. */
+export declare const DirectoryExecutionPolicySchema: z.ZodObject<{
+    reviewed: z.ZodBoolean;
+    allowed_executor_ids: z.ZodArray<z.ZodString>;
+    allowed_provider_ids: z.ZodArray<z.ZodString>;
+    channel: z.ZodLiteral<"email">;
+    allowed_hours_utc: z.ZodArray<z.ZodNumber>;
+    contact_cooldown_hours: z.ZodNumber;
+    max_actions_per_utc_day: z.ZodNumber;
+    preparation_lease_seconds: z.ZodNumber;
+}, z.core.$strict>;
+export declare const DirectoryActionStateSchema: z.ZodEnum<{
+    unknown: "unknown";
+    invalidated: "invalidated";
+    reserved: "reserved";
+    dispatching: "dispatching";
+    accepted: "accepted";
+    delivered: "delivered";
+    rejected: "rejected";
+}>;
+export declare const DirectoryActionSchema: z.ZodObject<{
+    id: z.ZodString;
+    plan_id: z.ZodString;
+    intent_id: z.ZodString;
+    subject_id: z.ZodString;
+    state: z.ZodEnum<{
+        unknown: "unknown";
+        invalidated: "invalidated";
+        reserved: "reserved";
+        dispatching: "dispatching";
+        accepted: "accepted";
+        delivered: "delivered";
+        rejected: "rejected";
+    }>;
+    provider: z.ZodString;
+    provider_idempotency_key: z.ZodString;
+    created_at: z.ZodISODateTime;
+    valid_until: z.ZodISODateTime;
+    lease_expires_at: z.ZodISODateTime;
+    accepted_at: z.ZodNullable<z.ZodISODateTime>;
+    attempt_id: z.ZodNullable<z.ZodString>;
+    simulation: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const DirectoryClaimRequest: z.ZodObject<{
+    plan_id: z.ZodString;
+    intent_ids: z.ZodArray<z.ZodString>;
+    provider: z.ZodString;
+}, z.core.$strict>;
+export declare const DirectoryClaimResponse: z.ZodObject<{
+    plan_id: z.ZodString;
+    actions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        plan_id: z.ZodString;
+        intent_id: z.ZodString;
+        subject_id: z.ZodString;
+        state: z.ZodEnum<{
+            unknown: "unknown";
+            invalidated: "invalidated";
+            reserved: "reserved";
+            dispatching: "dispatching";
+            accepted: "accepted";
+            delivered: "delivered";
+            rejected: "rejected";
+        }>;
+        provider: z.ZodString;
+        provider_idempotency_key: z.ZodString;
+        created_at: z.ZodISODateTime;
+        valid_until: z.ZodISODateTime;
+        lease_expires_at: z.ZodISODateTime;
+        accepted_at: z.ZodNullable<z.ZodISODateTime>;
+        attempt_id: z.ZodNullable<z.ZodString>;
+        simulation: z.ZodBoolean;
+        lease_token: z.ZodString;
+        endpoint: z.ZodEmail;
+        authority: z.ZodLiteral<"preparation_only">;
+    }, z.core.$strict>>;
+    exclusions: z.ZodArray<z.ZodObject<{
+        intent_id: z.ZodString;
+        code: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const DirectoryStartRequest: z.ZodObject<{
+    id: z.ZodString;
+    lease_token: z.ZodString;
+}, z.core.$strict>;
+export declare const DirectoryAttemptSchema: z.ZodObject<{
+    id: z.ZodString;
+    action_id: z.ZodString;
+    provider: z.ZodString;
+    provider_idempotency_key: z.ZodString;
+    state: z.ZodEnum<{
+        unknown: "unknown";
+        invalidated: "invalidated";
+        reserved: "reserved";
+        dispatching: "dispatching";
+        accepted: "accepted";
+        delivered: "delivered";
+        rejected: "rejected";
+    }>;
+    started_at: z.ZodISODateTime;
+    replayed: z.ZodBoolean;
+    instruction: z.ZodEnum<{
+        execute_once: "execute_once";
+        reconcile_only: "reconcile_only";
+    }>;
+    simulation: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const DirectoryOutcomeRequest: z.ZodObject<{
+    outcomes: z.ZodArray<z.ZodObject<{
+        event_id: z.ZodString;
+        action_id: z.ZodString;
+        attempt_id: z.ZodString;
+        provider: z.ZodString;
+        provider_event_id: z.ZodString;
+        outcome: z.ZodEnum<{
+            unknown: "unknown";
+            accepted: "accepted";
+            delivered: "delivered";
+            rejected: "rejected";
+            bounced: "bounced";
+            complained: "complained";
+        }>;
+        occurred_at: z.ZodISODateTime;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const DirectoryOutcomeResponse: z.ZodObject<{
+    results: z.ZodArray<z.ZodObject<{
+        event_id: z.ZodString;
+        status: z.ZodEnum<{
+            accepted: "accepted";
+            rejected: "rejected";
+            duplicate: "duplicate";
+        }>;
+        code: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const DirectorySalesDiscoveryRequest: z.ZodObject<{
+    dataset_id: z.ZodString;
+    profile_id: z.ZodString;
+    audience_id: z.ZodString;
+    cursor: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strict>;
+export declare const DirectorySalesDiscoveryResponse: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            office: "office";
+            professional: "professional";
+            organization: "organization";
+        }>;
+        revision: z.ZodString;
+    }, z.core.$strict>>;
+    next_cursor: z.ZodNullable<z.ZodString>;
+    selection_scope: z.ZodLiteral<"bounded_discovery_page">;
+    eligibility: z.ZodLiteral<"requires_plan_evaluation">;
+}, z.core.$strict>;
+export declare const directoryExecutionOperations: {
+    readonly discoverDirectorySalesCandidates: {
+        readonly input: z.ZodObject<{
+            dataset_id: z.ZodString;
+            profile_id: z.ZodString;
+            audience_id: z.ZodString;
+            cursor: z.ZodOptional<z.ZodString>;
+            limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+        }, z.core.$strict>;
+        readonly output: z.ZodObject<{
+            data: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                kind: z.ZodEnum<{
+                    office: "office";
+                    professional: "professional";
+                    organization: "organization";
+                }>;
+                revision: z.ZodString;
+            }, z.core.$strict>>;
+            next_cursor: z.ZodNullable<z.ZodString>;
+            selection_scope: z.ZodLiteral<"bounded_discovery_page">;
+            eligibility: z.ZodLiteral<"requires_plan_evaluation">;
+        }, z.core.$strict>;
+    };
+    readonly claimDirectoryActions: {
+        readonly input: z.ZodObject<{
+            plan_id: z.ZodString;
+            intent_ids: z.ZodArray<z.ZodString>;
+            provider: z.ZodString;
+        }, z.core.$strict>;
+        readonly output: z.ZodObject<{
+            plan_id: z.ZodString;
+            actions: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                plan_id: z.ZodString;
+                intent_id: z.ZodString;
+                subject_id: z.ZodString;
+                state: z.ZodEnum<{
+                    unknown: "unknown";
+                    invalidated: "invalidated";
+                    reserved: "reserved";
+                    dispatching: "dispatching";
+                    accepted: "accepted";
+                    delivered: "delivered";
+                    rejected: "rejected";
+                }>;
+                provider: z.ZodString;
+                provider_idempotency_key: z.ZodString;
+                created_at: z.ZodISODateTime;
+                valid_until: z.ZodISODateTime;
+                lease_expires_at: z.ZodISODateTime;
+                accepted_at: z.ZodNullable<z.ZodISODateTime>;
+                attempt_id: z.ZodNullable<z.ZodString>;
+                simulation: z.ZodBoolean;
+                lease_token: z.ZodString;
+                endpoint: z.ZodEmail;
+                authority: z.ZodLiteral<"preparation_only">;
+            }, z.core.$strict>>;
+            exclusions: z.ZodArray<z.ZodObject<{
+                intent_id: z.ZodString;
+                code: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    };
+    readonly startDirectoryAttempt: {
+        readonly input: z.ZodObject<{
+            id: z.ZodString;
+            lease_token: z.ZodString;
+        }, z.core.$strict>;
+        readonly output: z.ZodObject<{
+            id: z.ZodString;
+            action_id: z.ZodString;
+            provider: z.ZodString;
+            provider_idempotency_key: z.ZodString;
+            state: z.ZodEnum<{
+                unknown: "unknown";
+                invalidated: "invalidated";
+                reserved: "reserved";
+                dispatching: "dispatching";
+                accepted: "accepted";
+                delivered: "delivered";
+                rejected: "rejected";
+            }>;
+            started_at: z.ZodISODateTime;
+            replayed: z.ZodBoolean;
+            instruction: z.ZodEnum<{
+                execute_once: "execute_once";
+                reconcile_only: "reconcile_only";
+            }>;
+            simulation: z.ZodBoolean;
+        }, z.core.$strict>;
+    };
+    readonly getDirectoryAction: {
+        readonly input: z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strict>;
+        readonly output: z.ZodObject<{
+            id: z.ZodString;
+            plan_id: z.ZodString;
+            intent_id: z.ZodString;
+            subject_id: z.ZodString;
+            state: z.ZodEnum<{
+                unknown: "unknown";
+                invalidated: "invalidated";
+                reserved: "reserved";
+                dispatching: "dispatching";
+                accepted: "accepted";
+                delivered: "delivered";
+                rejected: "rejected";
+            }>;
+            provider: z.ZodString;
+            provider_idempotency_key: z.ZodString;
+            created_at: z.ZodISODateTime;
+            valid_until: z.ZodISODateTime;
+            lease_expires_at: z.ZodISODateTime;
+            accepted_at: z.ZodNullable<z.ZodISODateTime>;
+            attempt_id: z.ZodNullable<z.ZodString>;
+            simulation: z.ZodBoolean;
+        }, z.core.$strict>;
+    };
+    readonly recordDirectoryActionOutcomes: {
+        readonly input: z.ZodObject<{
+            outcomes: z.ZodArray<z.ZodObject<{
+                event_id: z.ZodString;
+                action_id: z.ZodString;
+                attempt_id: z.ZodString;
+                provider: z.ZodString;
+                provider_event_id: z.ZodString;
+                outcome: z.ZodEnum<{
+                    unknown: "unknown";
+                    accepted: "accepted";
+                    delivered: "delivered";
+                    rejected: "rejected";
+                    bounced: "bounced";
+                    complained: "complained";
+                }>;
+                occurred_at: z.ZodISODateTime;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        readonly output: z.ZodObject<{
+            results: z.ZodArray<z.ZodObject<{
+                event_id: z.ZodString;
+                status: z.ZodEnum<{
+                    accepted: "accepted";
+                    rejected: "rejected";
+                    duplicate: "duplicate";
+                }>;
+                code: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    };
+};
+export type DirectoryExecutionPolicy = z.infer<typeof DirectoryExecutionPolicySchema>;
+export type DirectoryAction = z.infer<typeof DirectoryActionSchema>;
+export type DirectoryClaimInput = z.output<typeof DirectoryClaimRequest>;
+export type DirectoryClaim = z.infer<typeof DirectoryClaimResponse>;
+export type DirectoryStartInput = z.infer<typeof DirectoryStartRequest>;
+export type DirectoryAttempt = z.infer<typeof DirectoryAttemptSchema>;
+export type DirectoryOutcomeInput = z.infer<typeof DirectoryOutcomeRequest>;
+export type DirectoryOutcomeResult = z.infer<typeof DirectoryOutcomeResponse>;
+export type DirectorySalesDiscoveryInput = z.output<typeof DirectorySalesDiscoveryRequest>;
+export type DirectorySalesDiscovery = z.infer<typeof DirectorySalesDiscoveryResponse>;

package/contracts/src/directory-execution.js

@@ -0,0 +1,122 @@
+import { z } from 'zod';
+const Id = z.string().min(1).max(256);
+const Time = z.iso.datetime({ offset: true });
+/** Separately provisioned authority. A recommendation policy never implicitly permits execution. */
+export const DirectoryExecutionPolicySchema = z.strictObject({
+    reviewed: z.boolean(),
+    allowed_executor_ids: z.array(Id).min(1).max(100),
+    allowed_provider_ids: z.array(Id).min(1).max(20),
+    channel: z.literal('email'),
+    allowed_hours_utc: z.array(z.number().int().min(0).max(23)).min(1).max(24),
+    contact_cooldown_hours: z.number().int().min(1).max(8760),
+    max_actions_per_utc_day: z.number().int().min(1).max(30000),
+    preparation_lease_seconds: z.number().int().min(30).max(300),
+});
+export const DirectoryActionStateSchema = z.enum([
+    'reserved',
+    'dispatching',
+    'unknown',
+    'accepted',
+    'delivered',
+    'rejected',
+    'invalidated',
+]);
+export const DirectoryActionSchema = z.strictObject({
+    id: Id,
+    plan_id: Id,
+    intent_id: Id,
+    subject_id: Id,
+    state: DirectoryActionStateSchema,
+    provider: Id,
+    provider_idempotency_key: Id,
+    created_at: Time,
+    valid_until: Time,
+    lease_expires_at: Time,
+    accepted_at: Time.nullable(),
+    attempt_id: Id.nullable(),
+    simulation: z.boolean(),
+});
+export const DirectoryClaimRequest = z.strictObject({
+    plan_id: Id,
+    intent_ids: z
+        .array(Id)
+        .min(1)
+        .max(50)
+        .refine((ids) => new Set(ids).size === ids.length),
+    provider: Id,
+});
+export const DirectoryClaimResponse = z.strictObject({
+    plan_id: Id,
+    actions: z.array(DirectoryActionSchema.extend({
+        lease_token: z.string().min(32).max(256),
+        endpoint: z.email(),
+        authority: z.literal('preparation_only'),
+    })),
+    exclusions: z.array(z.strictObject({ intent_id: Id, code: Id })),
+});
+export const DirectoryStartRequest = z.strictObject({
+    id: Id,
+    lease_token: z.string().min(32).max(256),
+});
+export const DirectoryAttemptSchema = z.strictObject({
+    id: Id,
+    action_id: Id,
+    provider: Id,
+    provider_idempotency_key: Id,
+    state: DirectoryActionStateSchema,
+    started_at: Time,
+    replayed: z.boolean(),
+    instruction: z.enum(['execute_once', 'reconcile_only']),
+    simulation: z.boolean(),
+});
+export const DirectoryOutcomeRequest = z.strictObject({
+    outcomes: z
+        .array(z.strictObject({
+        event_id: Id,
+        action_id: Id,
+        attempt_id: Id,
+        provider: Id,
+        provider_event_id: Id,
+        outcome: z.enum(['accepted', 'delivered', 'rejected', 'unknown', 'bounced', 'complained']),
+        occurred_at: Time,
+    }))
+        .min(1)
+        .max(100),
+});
+export const DirectoryOutcomeResponse = z.strictObject({
+    results: z.array(z.strictObject({
+        event_id: Id,
+        status: z.enum(['accepted', 'duplicate', 'rejected']),
+        code: Id.nullable(),
+    })),
+});
+export const DirectorySalesDiscoveryRequest = z.strictObject({
+    dataset_id: Id,
+    profile_id: Id,
+    audience_id: Id,
+    cursor: z.string().min(1).max(4096).optional(),
+    limit: z.coerce.number().int().min(1).max(500).default(100),
+});
+export const DirectorySalesDiscoveryResponse = z.strictObject({
+    data: z.array(z.strictObject({
+        id: Id,
+        kind: z.enum(['professional', 'office', 'organization']),
+        revision: z.string(),
+    })),
+    next_cursor: z.string().nullable(),
+    selection_scope: z.literal('bounded_discovery_page'),
+    eligibility: z.literal('requires_plan_evaluation'),
+});
+export const directoryExecutionOperations = {
+    discoverDirectorySalesCandidates: {
+        input: DirectorySalesDiscoveryRequest,
+        output: DirectorySalesDiscoveryResponse,
+    },
+    claimDirectoryActions: { input: DirectoryClaimRequest, output: DirectoryClaimResponse },
+    startDirectoryAttempt: { input: DirectoryStartRequest, output: DirectoryAttemptSchema },
+    getDirectoryAction: { input: z.strictObject({ id: Id }), output: DirectoryActionSchema },
+    recordDirectoryActionOutcomes: {
+        input: DirectoryOutcomeRequest,
+        output: DirectoryOutcomeResponse,
+    },
+};