@phpsandbox/sdk 0.4.0 → 0.6.0-canary.0

package/dist/customers.d.ts

@@ -0,0 +1,430 @@
+import { z } from 'zod';
+import type { Client } from './index.js';
+declare const customerConfigurationSchema: z.ZodObject<{
+    funnel: z.ZodNullable<z.ZodObject<{
+        title: z.ZodString;
+        stages: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            measure: z.ZodLiteral<"event">;
+            event: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            measure: z.ZodLiteral<"first_payment">;
+        }, z.core.$strip>, z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            measure: z.ZodLiteral<"event_after_payment">;
+            event: z.ZodString;
+        }, z.core.$strip>], "measure">>;
+    }, z.core.$strip>>;
+    followUp: z.ZodNullable<z.ZodObject<{
+        label: z.ZodString;
+        triggerEvent: z.ZodString;
+        prerequisiteEvent: z.ZodNullable<z.ZodString>;
+        stopOnPayment: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CustomerConfiguration = z.infer<typeof customerConfigurationSchema>;
+export declare const customerModeSchema: z.ZodEnum<{
+    test: "test";
+    live: "live";
+}>;
+export type CustomerMode = z.infer<typeof customerModeSchema>;
+export declare const customerSchema: z.ZodObject<{
+    id: z.ZodString;
+    externalId: z.ZodString;
+    email: z.ZodString;
+    name: z.ZodNullable<z.ZodString>;
+    source: z.ZodNullable<z.ZodString>;
+    marketingSubscribed: z.ZodBoolean;
+    communicationBasis: z.ZodOptional<z.ZodEnum<{
+        unknown: "unknown";
+        legacy_account: "legacy_account";
+        explicit_opt_in: "explicit_opt_in";
+        unsubscribed: "unsubscribed";
+    }>>;
+    legacyPolicy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    joinedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    importedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    lastActiveAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    billingStatus: z.ZodOptional<z.ZodEnum<{
+        unknown: "unknown";
+        paid: "paid";
+        free: "free";
+    }>>;
+    suppressionReason: z.ZodNullable<z.ZodString>;
+    activatedAt: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type CustomerData = z.infer<typeof customerSchema>;
+declare const spaceSchema: z.ZodObject<{
+    id: z.ZodString;
+    mode: z.ZodEnum<{
+        test: "test";
+        live: "live";
+    }>;
+    enabled: z.ZodBoolean;
+    senderName: z.ZodNullable<z.ZodString>;
+    senderEmail: z.ZodNullable<z.ZodString>;
+    replyTo: z.ZodNullable<z.ZodString>;
+    senderVerified: z.ZodBoolean;
+    domainRecords: z.ZodNullable<z.ZodString>;
+    configuration: z.ZodOptional<z.ZodObject<{
+        funnel: z.ZodNullable<z.ZodObject<{
+            title: z.ZodString;
+            stages: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                measure: z.ZodLiteral<"event">;
+                event: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                measure: z.ZodLiteral<"first_payment">;
+            }, z.core.$strip>, z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                measure: z.ZodLiteral<"event_after_payment">;
+                event: z.ZodString;
+            }, z.core.$strip>], "measure">>;
+        }, z.core.$strip>>;
+        followUp: z.ZodNullable<z.ZodObject<{
+            label: z.ZodString;
+            triggerEvent: z.ZodString;
+            prerequisiteEvent: z.ZodNullable<z.ZodString>;
+            stopOnPayment: z.ZodBoolean;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    emailTemplate: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    provisionedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    lastRequestAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    processedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type CustomerSpaceData = z.infer<typeof spaceSchema>;
+declare const journeyInputSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    subject: z.ZodString;
+    body: z.ZodString;
+    delayMinutes: z.ZodNumber;
+    activationEvent: z.ZodString;
+}, z.core.$strip>;
+export type CustomerJourneyInput = z.infer<typeof journeyInputSchema>;
+declare const journeySchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    subject: z.ZodString;
+    body: z.ZodString;
+    delayMinutes: z.ZodNumber;
+    activationEvent: z.ZodString;
+    kind: z.ZodEnum<{
+        setup: "setup";
+        welcome: "welcome";
+        purchase: "purchase";
+        credit_limit: "credit_limit";
+    }>;
+    version: z.ZodOptional<z.ZodNumber>;
+    startsAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    draft: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        subject: z.ZodString;
+        body: z.ZodString;
+        delayMinutes: z.ZodNumber;
+        activationEvent: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type CustomerJourneyData = z.infer<typeof journeySchema>;
+declare const messageSchema: z.ZodObject<{
+    id: z.ZodString;
+    customerId: z.ZodNullable<z.ZodString>;
+    recipient: z.ZodString;
+    subject: z.ZodString;
+    body: z.ZodString;
+    status: z.ZodString;
+    error: z.ZodNullable<z.ZodString>;
+    dueAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    attemptedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    receivedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    journeyKind: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        setup: "setup";
+        welcome: "welcome";
+        purchase: "purchase";
+        credit_limit: "credit_limit";
+    }>>>;
+    journeyVersion: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    category: z.ZodOptional<z.ZodEnum<{
+        marketing: "marketing";
+        service: "service";
+    }>>;
+    from: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    replyTo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    renderedText: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    renderedHtml: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    unsubscribeUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    createdAt: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type CustomerMessageData = z.infer<typeof messageSchema>;
+declare const overviewSchema: z.ZodObject<{
+    funnel: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        title: z.ZodString;
+        stages: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            count: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    space: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        mode: z.ZodEnum<{
+            test: "test";
+            live: "live";
+        }>;
+        enabled: z.ZodBoolean;
+        senderName: z.ZodNullable<z.ZodString>;
+        senderEmail: z.ZodNullable<z.ZodString>;
+        replyTo: z.ZodNullable<z.ZodString>;
+        senderVerified: z.ZodBoolean;
+        domainRecords: z.ZodNullable<z.ZodString>;
+        configuration: z.ZodOptional<z.ZodObject<{
+            funnel: z.ZodNullable<z.ZodObject<{
+                title: z.ZodString;
+                stages: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    measure: z.ZodLiteral<"event">;
+                    event: z.ZodString;
+                }, z.core.$strip>, z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    measure: z.ZodLiteral<"first_payment">;
+                }, z.core.$strip>, z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    measure: z.ZodLiteral<"event_after_payment">;
+                    event: z.ZodString;
+                }, z.core.$strip>], "measure">>;
+            }, z.core.$strip>>;
+            followUp: z.ZodNullable<z.ZodObject<{
+                label: z.ZodString;
+                triggerEvent: z.ZodString;
+                prerequisiteEvent: z.ZodNullable<z.ZodString>;
+                stopOnPayment: z.ZodBoolean;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        emailTemplate: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        provisionedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        lastRequestAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        processedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+    customers: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        externalId: z.ZodString;
+        email: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+        source: z.ZodNullable<z.ZodString>;
+        marketingSubscribed: z.ZodBoolean;
+        communicationBasis: z.ZodOptional<z.ZodEnum<{
+            unknown: "unknown";
+            legacy_account: "legacy_account";
+            explicit_opt_in: "explicit_opt_in";
+            unsubscribed: "unsubscribed";
+        }>>;
+        legacyPolicy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        joinedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        importedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        lastActiveAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        billingStatus: z.ZodOptional<z.ZodEnum<{
+            unknown: "unknown";
+            paid: "paid";
+            free: "free";
+        }>>;
+        suppressionReason: z.ZodNullable<z.ZodString>;
+        activatedAt: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    journeys: z.ZodArray<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        subject: z.ZodString;
+        body: z.ZodString;
+        delayMinutes: z.ZodNumber;
+        activationEvent: z.ZodString;
+        kind: z.ZodEnum<{
+            setup: "setup";
+            welcome: "welcome";
+            purchase: "purchase";
+            credit_limit: "credit_limit";
+        }>;
+        version: z.ZodOptional<z.ZodNumber>;
+        startsAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        draft: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            enabled: z.ZodBoolean;
+            subject: z.ZodString;
+            body: z.ZodString;
+            delayMinutes: z.ZodNumber;
+            activationEvent: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    messages: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        customerId: z.ZodNullable<z.ZodString>;
+        recipient: z.ZodString;
+        subject: z.ZodString;
+        body: z.ZodString;
+        status: z.ZodString;
+        error: z.ZodNullable<z.ZodString>;
+        dueAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        attemptedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        receivedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        journeyKind: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            setup: "setup";
+            welcome: "welcome";
+            purchase: "purchase";
+            credit_limit: "credit_limit";
+        }>>>;
+        journeyVersion: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        category: z.ZodOptional<z.ZodEnum<{
+            marketing: "marketing";
+            service: "service";
+        }>>;
+        from: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        replyTo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        renderedText: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        renderedHtml: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        unsubscribeUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        createdAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    total: z.ZodNumber;
+    messageTotal: z.ZodOptional<z.ZodNumber>;
+    events: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type CustomersOverview = z.infer<typeof overviewSchema>;
+export interface IdentifyCustomerInput {
+    externalId: string;
+    email: string;
+    name?: string | null;
+    source?: string;
+    billingStatus?: 'unknown' | 'free' | 'paid';
+    /** Original registration time, independent of the Customers record creation time. */
+    joinedAt?: string;
+    lastActiveAt?: string;
+    /** Historical synchronization never enrolls signup journeys. */
+    historical?: boolean;
+    /** Explicit eligibility policy for accounts with unknown preferences; this does not record consent. */
+    legacyPolicy?: string;
+    /** Import known suppressions. Identification can never clear an existing suppression. */
+    suppressionReason?: string;
+    /** Preserve a known unsubscribe atomically during account identification. Never clears an unsubscribe. */
+    unsubscribed?: true;
+    /** Original known unsubscribe time. A later explicit opt-in remains authoritative. */
+    unsubscribedAt?: string;
+}
+export interface CustomerEventInput {
+    eventId: string;
+    name: string;
+    organizationExternalId?: string;
+    occurredAt?: string;
+    /** Preserve activity history without activating or enrolling a customer. */
+    historical?: boolean;
+    properties?: Record<string, string | number | boolean | null>;
+}
+export interface CustomerOrganizationInput {
+    externalId: string;
+    name: string;
+    ownerExternalId: string;
+    /** Complete current membership snapshot. The owner is always included. */
+    members: {
+        externalId: string;
+        role: string;
+    }[];
+}
+export interface CustomerPaymentInput {
+    paymentId: string;
+    amountMinor: number;
+    currency: string;
+    paidAt: string;
+    historical?: boolean;
+}
+declare const customerOrganizationSchema: z.ZodObject<{
+    id: z.ZodString;
+    externalId: z.ZodString;
+    name: z.ZodString;
+    ownerCustomerId: z.ZodString;
+    firstPaidAt: z.ZodNullable<z.ZodString>;
+    activatedAt: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type CustomerOrganizationData = z.infer<typeof customerOrganizationSchema>;
+export interface SendCustomerMessageInput {
+    requestId: string;
+    subject: string;
+    body: string;
+    category: 'service' | 'marketing';
+}
+/** Use only from trusted app servers with a dedicated Customers credential. */
+export declare class CustomerRuntime {
+    private readonly client;
+    constructor(client: Client);
+    /** Configure this application's event funnel and follow-up rules. Does not activate messaging. */
+    configure(input: CustomerConfiguration & {
+        emailTemplate?: string | null;
+    }): Promise<CustomerConfiguration>;
+    /** Inspect the workspace and environment selected by this app credential. */
+    context(): Promise<{
+        id: string;
+        notebookId: string;
+        mode: CustomerMode;
+    }>;
+    /** Pull due conversion follow-ups, then recheck authoritative billing, credit and access. */
+    pendingFollowUps(): Promise<{
+        messageId: string;
+        organizationExternalId: string;
+        actorExternalId: string;
+    }[]>;
+    /** Eligible deliveries run immediately; expired checks are never reused by a later worker. */
+    resolveFollowUp(messageId: string, resolution: 'eligible' | 'ineligible' | 'paid' | 'credits_available' | 'access_changed'): Promise<CustomerMessageData>;
+    organization(input: CustomerOrganizationInput): Promise<CustomerOrganizationData>;
+    /** Report only server-confirmed positive payments from your existing billing integration. */
+    confirmPayment(organizationExternalId: string, input: CustomerPaymentInput): Promise<CustomerOrganizationData>;
+    identify(input: IdentifyCustomerInput): Promise<CustomerData>;
+    linkIdentity(customerId: string, externalId: string): Promise<CustomerData>;
+    get(customerId: string): Promise<CustomerData>;
+    event(customerId: string, input: CustomerEventInput): Promise<{
+        id: string;
+        name: string;
+    }>;
+    preferences(customerId: string, input: {
+        subscribed: boolean;
+        source: string;
+        occurredAt?: string;
+    }): Promise<CustomerData>;
+    send(customerId: string, input: SendCustomerMessageInput): Promise<CustomerMessageData>;
+}
+export declare class CustomersApi {
+    private readonly client;
+    readonly runtime: CustomerRuntime;
+    constructor(client: Client);
+    forNotebook(notebookId: string): NotebookCustomers;
+}
+export declare class NotebookCustomers {
+    private readonly notebookId;
+    private readonly client;
+    constructor(notebookId: string, client: Client);
+    list(mode?: CustomerMode, query?: {
+        search?: string;
+        page?: number;
+        messagePage?: number;
+    }): Promise<CustomersOverview>;
+    connect(mode?: CustomerMode): Promise<CustomerSpaceData>;
+    provision(mode?: CustomerMode): Promise<CustomerSpaceData>;
+    disable(mode?: CustomerMode): Promise<CustomerSpaceData>;
+    resume(mode?: CustomerMode): Promise<CustomerSpaceData>;
+    rotate(mode?: CustomerMode): Promise<CustomerSpaceData>;
+    sender(input: {
+        senderName: string;
+        senderEmail: string;
+        replyTo: string;
+    }, mode?: CustomerMode): Promise<CustomerSpaceData>;
+    verifySender(mode?: CustomerMode): Promise<CustomerSpaceData>;
+    journey(kind: CustomerJourneyData['kind'], input: CustomerJourneyInput, mode?: CustomerMode): Promise<CustomerJourneyData>;
+    private path;
+}
+export {};

package/dist/customers.js

@@ -0,0 +1,242 @@
+// credit_limit is retained as the compatibility identifier for the application-configured event follow-up.
+import { z } from 'zod';
+const eventName = z.string().trim().min(1).max(100);
+const customerConfigurationSchema = z.object({
+    funnel: z
+        .object({
+        title: z.string().trim().min(1).max(100),
+        stages: z
+            .array(z.discriminatedUnion('measure', [
+            z.object({
+                id: z
+                    .string()
+                    .regex(/^[a-zA-Z0-9_-]+$/)
+                    .max(50),
+                label: z.string().trim().min(1).max(100),
+                measure: z.literal('event'),
+                event: eventName,
+            }),
+            z.object({
+                id: z
+                    .string()
+                    .regex(/^[a-zA-Z0-9_-]+$/)
+                    .max(50),
+                label: z.string().trim().min(1).max(100),
+                measure: z.literal('first_payment'),
+            }),
+            z.object({
+                id: z
+                    .string()
+                    .regex(/^[a-zA-Z0-9_-]+$/)
+                    .max(50),
+                label: z.string().trim().min(1).max(100),
+                measure: z.literal('event_after_payment'),
+                event: eventName,
+            }),
+        ]))
+            .max(12),
+    })
+        .nullable(),
+    followUp: z
+        .object({
+        label: z.string().trim().min(1).max(100),
+        triggerEvent: eventName,
+        prerequisiteEvent: eventName.nullable(),
+        stopOnPayment: z.boolean(),
+    })
+        .nullable(),
+});
+export const customerModeSchema = z.enum(['test', 'live']);
+export const customerSchema = z.object({
+    id: z.string(),
+    externalId: z.string(),
+    email: z.string(),
+    name: z.string().nullable(),
+    source: z.string().nullable(),
+    marketingSubscribed: z.boolean(),
+    communicationBasis: z.enum(['unknown', 'legacy_account', 'explicit_opt_in', 'unsubscribed']).optional(),
+    legacyPolicy: z.string().nullable().optional(),
+    joinedAt: z.string().nullable().optional(),
+    importedAt: z.string().nullable().optional(),
+    lastActiveAt: z.string().nullable().optional(),
+    billingStatus: z.enum(['unknown', 'free', 'paid']).optional(),
+    suppressionReason: z.string().nullable(),
+    activatedAt: z.string().nullable(),
+    createdAt: z.string().nullable(),
+});
+const spaceSchema = z.object({
+    id: z.string(),
+    mode: customerModeSchema,
+    enabled: z.boolean(),
+    senderName: z.string().nullable(),
+    senderEmail: z.string().nullable(),
+    replyTo: z.string().nullable(),
+    senderVerified: z.boolean(),
+    domainRecords: z.string().nullable(),
+    configuration: customerConfigurationSchema.optional(),
+    emailTemplate: z.string().nullable().optional(),
+    provisionedAt: z.string().nullable().optional(),
+    lastRequestAt: z.string().nullable().optional(),
+    processedAt: z.string().nullable().optional(),
+});
+const journeyInputSchema = z.object({
+    enabled: z.boolean(),
+    subject: z.string(),
+    body: z.string(),
+    delayMinutes: z.number(),
+    activationEvent: z.string(),
+});
+const journeySchema = journeyInputSchema.extend({
+    kind: z.enum(['welcome', 'setup', 'purchase', 'credit_limit']),
+    version: z.number().int().optional(),
+    startsAt: z.string().nullable().optional(),
+    draft: journeyInputSchema.nullable().optional(),
+});
+const messageSchema = z.object({
+    id: z.string(),
+    customerId: z.string().nullable(),
+    recipient: z.string(),
+    subject: z.string(),
+    body: z.string(),
+    status: z.string(),
+    error: z.string().nullable(),
+    dueAt: z.string().nullable().optional(),
+    attemptedAt: z.string().nullable().optional(),
+    receivedAt: z.string().nullable().optional(),
+    journeyKind: z.enum(['welcome', 'setup', 'purchase', 'credit_limit']).nullable().optional(),
+    journeyVersion: z.number().int().nullable().optional(),
+    category: z.enum(['marketing', 'service']).optional(),
+    from: z.string().nullable().optional(),
+    replyTo: z.string().nullable().optional(),
+    renderedText: z.string().nullable().optional(),
+    renderedHtml: z.string().nullable().optional(),
+    unsubscribeUrl: z.string().nullable().optional(),
+    createdAt: z.string().nullable(),
+});
+const overviewSchema = z.object({
+    funnel: z
+        .object({ title: z.string(), stages: z.array(z.object({ id: z.string(), label: z.string(), count: z.number() })) })
+        .nullable()
+        .optional(),
+    space: spaceSchema.nullable(),
+    customers: z.array(customerSchema),
+    journeys: z.array(journeySchema),
+    messages: z.array(messageSchema),
+    total: z.number(),
+    messageTotal: z.number().optional(),
+    events: z.array(z.string()).optional(),
+});
+const customerOrganizationSchema = z.object({
+    id: z.string(),
+    externalId: z.string(),
+    name: z.string(),
+    ownerCustomerId: z.string(),
+    firstPaidAt: z.string().nullable(),
+    activatedAt: z.string().nullable(),
+});
+/** Use only from trusted app servers with a dedicated Customers credential. */
+export class CustomerRuntime {
+    constructor(client) {
+        this.client = client;
+    }
+    /** Configure this application's event funnel and follow-up rules. Does not activate messaging. */
+    async configure(input) {
+        const configuration = customerConfigurationSchema.parse(input);
+        return customerConfigurationSchema.parse((await this.client.put('/platform/customers/runtime/configuration', {
+            ...configuration,
+            ...(input.emailTemplate !== undefined ? { emailTemplate: input.emailTemplate } : {}),
+        })).data);
+    }
+    /** Inspect the workspace and environment selected by this app credential. */
+    async context() {
+        return z
+            .object({ id: z.string(), notebookId: z.string(), mode: customerModeSchema })
+            .parse((await this.client.get('/platform/customers/runtime/context')).data);
+    }
+    /** Pull due conversion follow-ups, then recheck authoritative billing, credit and access. */
+    async pendingFollowUps() {
+        return z
+            .array(z.object({ messageId: z.string(), organizationExternalId: z.string(), actorExternalId: z.string() }))
+            .parse((await this.client.get('/platform/customers/runtime/follow-ups')).data);
+    }
+    /** Eligible deliveries run immediately; expired checks are never reused by a later worker. */
+    async resolveFollowUp(messageId, resolution) {
+        return messageSchema.parse((await this.client.post(`/platform/customers/runtime/follow-ups/${encodeURIComponent(messageId)}/resolve`, {
+            resolution,
+        })).data);
+    }
+    async organization(input) {
+        return customerOrganizationSchema.parse((await this.client.put('/platform/customers/runtime/organizations', input)).data);
+    }
+    /** Report only server-confirmed positive payments from your existing billing integration. */
+    async confirmPayment(organizationExternalId, input) {
+        return customerOrganizationSchema.parse((await this.client.post(`/platform/customers/runtime/organizations/${encodeURIComponent(organizationExternalId)}/payments`, input)).data);
+    }
+    async identify(input) {
+        return customerSchema.parse((await this.client.post('/platform/customers/runtime/identify', input)).data);
+    }
+    async linkIdentity(customerId, externalId) {
+        return customerSchema.parse((await this.client.post(`/platform/customers/runtime/${encodeURIComponent(customerId)}/identities`, {
+            externalId,
+        })).data);
+    }
+    async get(customerId) {
+        return customerSchema.parse((await this.client.get(`/platform/customers/runtime/${encodeURIComponent(customerId)}`)).data);
+    }
+    async event(customerId, input) {
+        return z
+            .object({ id: z.string(), name: z.string() })
+            .parse((await this.client.post(`/platform/customers/runtime/${encodeURIComponent(customerId)}/events`, input)).data);
+    }
+    async preferences(customerId, input) {
+        return customerSchema.parse((await this.client.put(`/platform/customers/runtime/${encodeURIComponent(customerId)}/preferences`, input)).data);
+    }
+    async send(customerId, input) {
+        return messageSchema.parse((await this.client.post(`/platform/customers/runtime/${encodeURIComponent(customerId)}/messages`, input)).data);
+    }
+}
+export class CustomersApi {
+    constructor(client) {
+        this.client = client;
+        this.runtime = new CustomerRuntime(client);
+    }
+    forNotebook(notebookId) {
+        return new NotebookCustomers(notebookId, this.client);
+    }
+}
+export class NotebookCustomers {
+    constructor(notebookId, client) {
+        this.notebookId = notebookId;
+        this.client = client;
+    }
+    async list(mode = 'test', query = {}) {
+        return overviewSchema.parse((await this.client.get(`${this.path(mode)}?${new URLSearchParams(Object.entries(query).map(([key, value]) => [key, String(value)])).toString()}`)).data);
+    }
+    async connect(mode = 'test') {
+        return spaceSchema.parse((await this.client.put(this.path(mode), {})).data);
+    }
+    async provision(mode = 'test') {
+        return spaceSchema.parse((await this.client.post(`${this.path(mode)}/provision`, {})).data);
+    }
+    async disable(mode = 'test') {
+        return spaceSchema.parse((await this.client.post(`${this.path(mode)}/disable`, {})).data);
+    }
+    async resume(mode = 'test') {
+        return spaceSchema.parse((await this.client.post(`${this.path(mode)}/resume`, {})).data);
+    }
+    async rotate(mode = 'test') {
+        return spaceSchema.parse((await this.client.post(`${this.path(mode)}/rotate`, {})).data);
+    }
+    async sender(input, mode = 'test') {
+        return spaceSchema.parse((await this.client.put(`${this.path(mode)}/sender`, input)).data);
+    }
+    async verifySender(mode = 'test') {
+        return spaceSchema.parse((await this.client.post(`${this.path(mode)}/sender/verify`, {})).data);
+    }
+    async journey(kind, input, mode = 'test') {
+        return journeySchema.parse((await this.client.put(`${this.path(mode)}/journeys/${kind}`, input)).data);
+    }
+    path(mode) {
+        return `/platform/customers/sandboxes/${encodeURIComponent(this.notebookId)}/${mode}`;
+    }
+}