@automate.ax/integration-contracts 0.143.9 → 0.144.0

package/dist/calendly/schemas.js

@@ -0,0 +1,420 @@
+import * as z from "zod";
+export const CALENDLY_DATE_TIME_SCHEMA = z.iso.datetime({ offset: true });
+export const CALENDLY_URI_SCHEMA = z.url();
+export const CALENDLY_UUID_SCHEMA = z
+    .string()
+    .trim()
+    .regex(/^[A-Za-z0-9_-]+$/, "Use a Calendly UUID, not a path or URL.");
+export const CALENDLY_PAGINATION_SCHEMA = z.object({
+    count: z.number().int().min(0).max(100),
+    nextPage: z.url().nullable(),
+    nextPageToken: z.string().nullable(),
+    previousPage: z.url().nullable(),
+    previousPageToken: z.string().nullable(),
+});
+export const CALENDLY_USER_SCHEMA = z.object({
+    avatarUrl: z.url().nullable(),
+    createdAt: CALENDLY_DATE_TIME_SCHEMA,
+    currentOrganization: CALENDLY_URI_SCHEMA,
+    email: z.email(),
+    locale: z.string(),
+    name: z.string(),
+    resourceType: z.string(),
+    schedulingUrl: CALENDLY_URI_SCHEMA,
+    slug: z.string(),
+    timeNotation: z.enum(["12h", "24h"]).optional(),
+    timezone: z.string(),
+    updatedAt: CALENDLY_DATE_TIME_SCHEMA,
+    uri: CALENDLY_URI_SCHEMA,
+});
+export const CALENDLY_ORGANIZATION_SCHEMA = z.object({
+    createdAt: CALENDLY_DATE_TIME_SCHEMA,
+    kind: z.enum(["solo", "group"]),
+    name: z.string().optional(),
+    plan: z.string(),
+    stage: z.string(),
+    updatedAt: CALENDLY_DATE_TIME_SCHEMA,
+    uri: CALENDLY_URI_SCHEMA,
+});
+export const CALENDLY_ORGANIZATION_MEMBERSHIP_SCHEMA = z.object({
+    createdAt: CALENDLY_DATE_TIME_SCHEMA,
+    organization: CALENDLY_URI_SCHEMA,
+    role: z.enum(["admin", "owner", "user"]),
+    updatedAt: CALENDLY_DATE_TIME_SCHEMA,
+    uri: CALENDLY_URI_SCHEMA,
+    user: CALENDLY_USER_SCHEMA.omit({
+        currentOrganization: true,
+        resourceType: true,
+    }),
+});
+const QUESTION_AND_ANSWER_SCHEMA = z.object({
+    answer: z.string(),
+    position: z.number().int(),
+    question: z.string(),
+});
+export const CALENDLY_EVENT_TYPE_SCHEMA = z.object({
+    active: z.boolean(),
+    adminManaged: z.boolean(),
+    bookingMethod: z.enum(["instant", "poll"]),
+    color: z.string().regex(/^#[a-f\d]{6}$/i),
+    createdAt: CALENDLY_DATE_TIME_SCHEMA,
+    customQuestions: z
+        .object({
+        answerChoices: z.string().array(),
+        enabled: z.boolean(),
+        includeOther: z.boolean(),
+        name: z.string(),
+        position: z.number().int(),
+        required: z.boolean(),
+        type: z.string(),
+    })
+        .array(),
+    deletedAt: CALENDLY_DATE_TIME_SCHEMA.nullable(),
+    descriptionHtml: z.string().nullable(),
+    descriptionPlain: z.string().nullable(),
+    duration: z.number().positive(),
+    durationOptions: z.number().int().positive().array().nullable(),
+    internalNote: z.string().nullable(),
+    isPaid: z.boolean(),
+    kind: z.enum(["solo", "group"]),
+    locale: z.string(),
+    locations: z
+        .object({
+        additionalInfo: z.string().optional(),
+        kind: z.string(),
+        location: z.string().optional(),
+        phoneNumber: z.string().optional(),
+    })
+        .array()
+        .nullable(),
+    name: z.string().nullable(),
+    poolingType: z.enum(["collective", "multi_pool", "round_robin"]).nullable(),
+    position: z.number().int().min(0),
+    profile: z.object({ name: z.string(), owner: CALENDLY_URI_SCHEMA }),
+    schedulingUrl: CALENDLY_URI_SCHEMA,
+    secret: z.boolean(),
+    slug: z.string().nullable(),
+    type: z.enum(["AdhocEventType", "StandardEventType"]),
+    updatedAt: CALENDLY_DATE_TIME_SCHEMA,
+    uri: CALENDLY_URI_SCHEMA,
+});
+export const CALENDLY_EVENT_TYPE_HOST_SCHEMA = z.object({
+    createdAt: CALENDLY_DATE_TIME_SCHEMA.optional(),
+    eventType: CALENDLY_EVENT_TYPE_SCHEMA,
+    member: CALENDLY_USER_SCHEMA.optional(),
+    updatedAt: CALENDLY_DATE_TIME_SCHEMA.optional(),
+    uri: CALENDLY_URI_SCHEMA,
+});
+export const CALENDLY_CANCELLATION_SCHEMA = z.object({
+    canceledBy: z.string(),
+    cancelerType: z.string(),
+    createdAt: CALENDLY_DATE_TIME_SCHEMA,
+    reason: z.string().nullable(),
+});
+export const CALENDLY_AVAILABLE_TIME_SCHEMA = z.object({
+    inviteesRemaining: z.number().int().min(0),
+    schedulingUrl: CALENDLY_URI_SCHEMA,
+    startTime: CALENDLY_DATE_TIME_SCHEMA,
+    status: z.literal("available"),
+});
+export const CALENDLY_AVAILABILITY_RULE_SCHEMA = z.object({
+    date: z.iso.date().optional(),
+    intervals: z
+        .object({
+        from: z.string().regex(/^\d\d:\d\d$/),
+        to: z.string().regex(/^\d\d:\d\d$/),
+    })
+        .array(),
+    type: z.enum(["date", "wday"]),
+    wday: z
+        .enum([
+        "sunday",
+        "monday",
+        "tuesday",
+        "wednesday",
+        "thursday",
+        "friday",
+        "saturday",
+    ])
+        .optional(),
+});
+export const CALENDLY_AVAILABILITY_SCHEDULE_SCHEMA = z.object({
+    default: z.boolean(),
+    name: z.string(),
+    rules: CALENDLY_AVAILABILITY_RULE_SCHEMA.array(),
+    timezone: z.string(),
+    uri: CALENDLY_URI_SCHEMA,
+    user: CALENDLY_URI_SCHEMA,
+});
+export const CALENDLY_EVENT_TYPE_AVAILABILITY_SCHEDULE_SCHEMA = z.object({
+    availabilityRule: z.object({
+        name: z.string().nullable().optional(),
+        rules: CALENDLY_AVAILABILITY_RULE_SCHEMA.array().optional(),
+        timezone: z.string().optional(),
+        uri: CALENDLY_URI_SCHEMA.optional(),
+        user: CALENDLY_URI_SCHEMA.optional(),
+    }),
+    availabilitySetting: z.literal("host"),
+    eventType: CALENDLY_URI_SCHEMA,
+});
+export const CALENDLY_MEETING_LOCATION_SCHEMA = z.object({
+    connected: z.boolean().optional(),
+    kind: z.enum([
+        "ask_invitee",
+        "custom",
+        "google_conference",
+        "gotomeeting_conference",
+        "inbound_call",
+        "microsoft_teams_conference",
+        "outbound_call",
+        "physical",
+        "webex_conference",
+        "zoom_conference",
+    ]),
+});
+export const CALENDLY_BUSY_TIME_SCHEMA = z.object({
+    bufferedEndTime: CALENDLY_DATE_TIME_SCHEMA.optional(),
+    bufferedStartTime: CALENDLY_DATE_TIME_SCHEMA.optional(),
+    endTime: CALENDLY_DATE_TIME_SCHEMA,
+    event: z.object({ uri: CALENDLY_URI_SCHEMA }).optional(),
+    startTime: CALENDLY_DATE_TIME_SCHEMA,
+    type: z.enum(["calendly", "external", "reserved"]),
+});
+export const CALENDLY_SCHEDULED_EVENT_SCHEMA = z.object({
+    cancellation: z
+        .object({
+        canceledBy: z.string(),
+        reason: z.string().nullable(),
+    })
+        .nullable()
+        .optional(),
+    createdAt: CALENDLY_DATE_TIME_SCHEMA,
+    endTime: CALENDLY_DATE_TIME_SCHEMA,
+    eventGuests: z
+        .object({
+        createdAt: CALENDLY_DATE_TIME_SCHEMA,
+        email: z.email(),
+        updatedAt: CALENDLY_DATE_TIME_SCHEMA,
+    })
+        .array(),
+    eventMemberships: z
+        .object({
+        bufferedEndTime: CALENDLY_DATE_TIME_SCHEMA.optional(),
+        bufferedStartTime: CALENDLY_DATE_TIME_SCHEMA.optional(),
+        user: CALENDLY_URI_SCHEMA,
+        userEmail: z.email().optional(),
+        userName: z.string().optional(),
+    })
+        .array(),
+    eventType: CALENDLY_URI_SCHEMA,
+    inviteesCounter: z.object({
+        active: z.number().int().min(0),
+        limit: z.number().int().min(0),
+        total: z.number().int().min(0),
+    }),
+    location: z.object({
+        additionalInfo: z.string().optional(),
+        joinUrl: CALENDLY_URI_SCHEMA.nullable().optional(),
+        location: z.string().nullable().optional(),
+        status: z.string().nullable().optional(),
+        type: z.string(),
+    }),
+    meetingNotesHtml: z.string().optional(),
+    meetingNotesPlain: z.string().nullable().optional(),
+    name: z.string().nullable(),
+    startTime: CALENDLY_DATE_TIME_SCHEMA,
+    status: z.enum(["active", "canceled"]),
+    updatedAt: CALENDLY_DATE_TIME_SCHEMA,
+    uri: CALENDLY_URI_SCHEMA,
+});
+export const CALENDLY_INVITEE_SCHEMA = z.object({
+    cancelUrl: CALENDLY_URI_SCHEMA,
+    cancellation: CALENDLY_CANCELLATION_SCHEMA.nullable().optional(),
+    createdAt: CALENDLY_DATE_TIME_SCHEMA,
+    email: z.email(),
+    event: CALENDLY_URI_SCHEMA,
+    firstName: z.string().nullable(),
+    inviteeScheduledBy: CALENDLY_URI_SCHEMA.nullable(),
+    lastName: z.string().nullable(),
+    name: z.string(),
+    newInvitee: CALENDLY_URI_SCHEMA.nullable(),
+    noShow: z
+        .object({
+        createdAt: CALENDLY_DATE_TIME_SCHEMA,
+        uri: CALENDLY_URI_SCHEMA,
+    })
+        .nullable(),
+    oldInvitee: CALENDLY_URI_SCHEMA.nullable(),
+    payment: z
+        .object({
+        amount: z.string(),
+        currency: z.string(),
+        externalId: z.string(),
+        provider: z.string(),
+        successful: z.boolean(),
+        terms: z.string().nullable(),
+    })
+        .nullable(),
+    questionsAndAnswers: QUESTION_AND_ANSWER_SCHEMA.array(),
+    reconfirmation: z
+        .object({
+        confirmedAt: CALENDLY_DATE_TIME_SCHEMA.nullable(),
+        createdAt: CALENDLY_DATE_TIME_SCHEMA,
+    })
+        .nullable(),
+    rescheduleUrl: CALENDLY_URI_SCHEMA,
+    rescheduled: z.boolean(),
+    routingFormSubmission: CALENDLY_URI_SCHEMA.nullable(),
+    schedulingMethod: z.enum(["api", "instant_book"]).nullable(),
+    status: z.enum(["active", "canceled"]),
+    textReminderNumber: z.string().nullable(),
+    timezone: z.string().nullable(),
+    tracking: z.object({
+        salesforceUuid: z.string().nullable().optional(),
+        utmCampaign: z.string().nullable().optional(),
+        utmContent: z.string().nullable().optional(),
+        utmMedium: z.string().nullable().optional(),
+        utmSource: z.string().nullable().optional(),
+        utmTerm: z.string().nullable().optional(),
+    }),
+    updatedAt: CALENDLY_DATE_TIME_SCHEMA,
+    uri: CALENDLY_URI_SCHEMA,
+});
+export const CALENDLY_INVITEE_NO_SHOW_SCHEMA = z.object({
+    createdAt: CALENDLY_DATE_TIME_SCHEMA,
+    invitee: CALENDLY_URI_SCHEMA,
+    uri: CALENDLY_URI_SCHEMA,
+});
+export const CALENDLY_ROUTING_FORM_SCHEMA = z.object({
+    createdAt: CALENDLY_DATE_TIME_SCHEMA,
+    name: z.string(),
+    organization: CALENDLY_URI_SCHEMA,
+    questions: z
+        .object({
+        answerChoices: z.string().array().nullable(),
+        name: z.string(),
+        required: z.boolean(),
+        type: z.string(),
+        uuid: z.string(),
+    })
+        .array(),
+    status: z.enum(["draft", "published"]),
+    updatedAt: CALENDLY_DATE_TIME_SCHEMA,
+    uri: CALENDLY_URI_SCHEMA,
+});
+export const CALENDLY_ROUTING_FORM_SUBMISSION_SCHEMA = z.object({
+    createdAt: CALENDLY_DATE_TIME_SCHEMA,
+    questionsAndAnswers: z
+        .object({
+        answer: z.string().nullable().optional(),
+        question: z.string(),
+        questionUuid: z.string().nullable(),
+    })
+        .array(),
+    result: z.discriminatedUnion("type", [
+        z.object({ type: z.literal("event_type"), value: CALENDLY_URI_SCHEMA }),
+        z.object({ type: z.literal("external_url"), value: CALENDLY_URI_SCHEMA }),
+        z.object({
+            type: z.literal("custom_message"),
+            value: z.object({ body: z.string(), headline: z.string() }),
+        }),
+    ]),
+    routingForm: CALENDLY_URI_SCHEMA,
+    submitter: CALENDLY_URI_SCHEMA.nullable(),
+    submitterType: z.literal("Invitee").nullable(),
+    tracking: z.object({
+        salesforceUuid: z.string().nullable(),
+        utmCampaign: z.string().nullable(),
+        utmContent: z.string().nullable(),
+        utmMedium: z.string().nullable(),
+        utmSource: z.string().nullable(),
+        utmTerm: z.string().nullable(),
+    }),
+    updatedAt: CALENDLY_DATE_TIME_SCHEMA,
+    uri: CALENDLY_URI_SCHEMA,
+});
+export const CALENDLY_SCHEDULING_LINK_SCHEMA = z.object({
+    bookingUrl: CALENDLY_URI_SCHEMA,
+    owner: CALENDLY_URI_SCHEMA.optional(),
+    ownerType: z.literal("EventType").optional(),
+});
+export const CALENDLY_TRIGGER_CONFIG_SCHEMA = z
+    .object({
+    groupUri: CALENDLY_URI_SCHEMA.optional(),
+    organizationUri: CALENDLY_URI_SCHEMA,
+    scope: z.enum(["group", "organization", "user"]),
+    userUri: CALENDLY_URI_SCHEMA.optional(),
+})
+    .superRefine((value, context) => {
+    if (value.scope === "user" && !value.userUri) {
+        context.addIssue({
+            code: "custom",
+            message: "userUri is required for user scope.",
+            path: ["userUri"],
+        });
+    }
+    if (value.scope === "group" && !value.groupUri) {
+        context.addIssue({
+            code: "custom",
+            message: "groupUri is required for group scope.",
+            path: ["groupUri"],
+        });
+    }
+});
+export const CALENDLY_ORGANIZATION_TRIGGER_CONFIG_SCHEMA = z.object({
+    organizationUri: CALENDLY_URI_SCHEMA,
+    scope: z.literal("organization"),
+});
+export const CALENDLY_PROVIDER_EVENT_NAMES = [
+    "event_type.created",
+    "event_type.deleted",
+    "event_type.updated",
+    "invitee.canceled",
+    "invitee.created",
+    "invitee_no_show.created",
+    "invitee_no_show.deleted",
+    "routing_form_submission.created",
+];
+export const CALENDLY_PROVIDER_EVENT_NAME_SCHEMA = z.enum(CALENDLY_PROVIDER_EVENT_NAMES);
+const CALENDLY_WEBHOOK_BASE_SCHEMA = z.object({
+    createdAt: CALENDLY_DATE_TIME_SCHEMA,
+    createdBy: CALENDLY_URI_SCHEMA,
+});
+const CALENDLY_EVENT_TYPE_WEBHOOK_PAYLOAD_SCHEMA = CALENDLY_EVENT_TYPE_SCHEMA.omit({ descriptionHtml: true });
+const CALENDLY_INVITEE_WEBHOOK_PAYLOAD_SCHEMA = CALENDLY_INVITEE_SCHEMA.extend({
+    scheduledEvent: CALENDLY_SCHEDULED_EVENT_SCHEMA,
+});
+export const CALENDLY_WEBHOOK_EVENT_SCHEMA = z.discriminatedUnion("event", [
+    CALENDLY_WEBHOOK_BASE_SCHEMA.extend({
+        event: z.literal("invitee.created"),
+        payload: CALENDLY_INVITEE_WEBHOOK_PAYLOAD_SCHEMA,
+    }),
+    CALENDLY_WEBHOOK_BASE_SCHEMA.extend({
+        event: z.literal("invitee.canceled"),
+        payload: CALENDLY_INVITEE_WEBHOOK_PAYLOAD_SCHEMA,
+    }),
+    CALENDLY_WEBHOOK_BASE_SCHEMA.extend({
+        event: z.literal("invitee_no_show.created"),
+        payload: CALENDLY_INVITEE_WEBHOOK_PAYLOAD_SCHEMA,
+    }),
+    CALENDLY_WEBHOOK_BASE_SCHEMA.extend({
+        event: z.literal("invitee_no_show.deleted"),
+        payload: CALENDLY_INVITEE_WEBHOOK_PAYLOAD_SCHEMA,
+    }),
+    CALENDLY_WEBHOOK_BASE_SCHEMA.extend({
+        event: z.literal("event_type.created"),
+        payload: CALENDLY_EVENT_TYPE_WEBHOOK_PAYLOAD_SCHEMA,
+    }),
+    CALENDLY_WEBHOOK_BASE_SCHEMA.extend({
+        event: z.literal("event_type.deleted"),
+        payload: CALENDLY_EVENT_TYPE_WEBHOOK_PAYLOAD_SCHEMA,
+    }),
+    CALENDLY_WEBHOOK_BASE_SCHEMA.extend({
+        event: z.literal("event_type.updated"),
+        payload: CALENDLY_EVENT_TYPE_WEBHOOK_PAYLOAD_SCHEMA,
+    }),
+    CALENDLY_WEBHOOK_BASE_SCHEMA.extend({
+        event: z.literal("routing_form_submission.created"),
+        payload: CALENDLY_ROUTING_FORM_SUBMISSION_SCHEMA,
+    }),
+]);

package/dist/close/events.d.ts

@@ -485,9 +485,9 @@ export declare const closeTriggerContracts: {
                 sequenceSubscriptionId: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
                 status: z.ZodOptional<z.ZodEnum<{
                     error: "error";
+                    draft: "draft";
                     sent: "sent";
                     inbox: "inbox";
-                    draft: "draft";
                     outbox: "outbox";
                     scheduled: "scheduled";
                 }>>;
@@ -573,9 +573,9 @@ export declare const closeTriggerContracts: {
                 sequenceSubscriptionId: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
                 status: z.ZodOptional<z.ZodEnum<{
                     error: "error";
+                    draft: "draft";
                     sent: "sent";
                     inbox: "inbox";
-                    draft: "draft";
                     outbox: "outbox";
                     scheduled: "scheduled";
                 }>>;
@@ -806,9 +806,9 @@ export declare const closeTriggerContracts: {
                 startsAt: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodString]>, z.ZodTransform<Date, string | Date>>>;
                 status: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
                     completed: "completed";
+                    canceled: "canceled";
                     "in-progress": "in-progress";
                     upcoming: "upcoming";
-                    canceled: "canceled";
                     "declined-by-org": "declined-by-org";
                     "declined-by-lead": "declined-by-lead";
                 }>>>;
@@ -880,9 +880,9 @@ export declare const closeTriggerContracts: {
                 startsAt: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodString]>, z.ZodTransform<Date, string | Date>>>;
                 status: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
                     completed: "completed";
+                    canceled: "canceled";
                     "in-progress": "in-progress";
                     upcoming: "upcoming";
-                    canceled: "canceled";
                     "declined-by-org": "declined-by-org";
                     "declined-by-lead": "declined-by-lead";
                 }>>>;
@@ -954,9 +954,9 @@ export declare const closeTriggerContracts: {
                 startsAt: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodString]>, z.ZodTransform<Date, string | Date>>>;
                 status: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
                     completed: "completed";
+                    canceled: "canceled";
                     "in-progress": "in-progress";
                     upcoming: "upcoming";
-                    canceled: "canceled";
                     "declined-by-org": "declined-by-org";
                     "declined-by-lead": "declined-by-lead";
                 }>>>;
@@ -1028,9 +1028,9 @@ export declare const closeTriggerContracts: {
                 startsAt: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodString]>, z.ZodTransform<Date, string | Date>>>;
                 status: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
                     completed: "completed";
+                    canceled: "canceled";
                     "in-progress": "in-progress";
                     upcoming: "upcoming";
-                    canceled: "canceled";
                     "declined-by-org": "declined-by-org";
                     "declined-by-lead": "declined-by-lead";
                 }>>>;
@@ -2160,9 +2160,9 @@ export declare const closeTriggerContracts: {
                 }>>;
                 status: z.ZodOptional<z.ZodEnum<{
                     error: "error";
+                    draft: "draft";
                     sent: "sent";
                     inbox: "inbox";
-                    draft: "draft";
                     outbox: "outbox";
                     scheduled: "scheduled";
                 }>>;
@@ -2231,9 +2231,9 @@ export declare const closeTriggerContracts: {
                 }>>;
                 status: z.ZodOptional<z.ZodEnum<{
                     error: "error";
+                    draft: "draft";
                     sent: "sent";
                     inbox: "inbox";
-                    draft: "draft";
                     outbox: "outbox";
                     scheduled: "scheduled";
                 }>>;

package/dist/close/schemas.d.ts

@@ -788,8 +788,8 @@ export declare const CLOSE_NOTE_SCHEMA: z.ZodObject<{
     pinnedAt: z.ZodNullable<z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodString]>, z.ZodTransform<Date, string | Date>>>;
     source: z.ZodNullable<z.ZodEnum<{
         email: "email";
-        ui: "ui";
         api: "api";
+        ui: "ui";
         import: "import";
         clipper: "clipper";
         suggestion: "suggestion";
@@ -905,9 +905,9 @@ export declare const CLOSE_EMAIL_SCHEMA: z.ZodObject<{
     sequenceSubscriptionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     status: z.ZodEnum<{
         error: "error";
+        draft: "draft";
         sent: "sent";
         inbox: "inbox";
-        draft: "draft";
         outbox: "outbox";
         scheduled: "scheduled";
     }>;
@@ -960,9 +960,9 @@ export declare const CLOSE_SMS_SCHEMA: z.ZodObject<{
     }>;
     status: z.ZodEnum<{
         error: "error";
+        draft: "draft";
         sent: "sent";
         inbox: "inbox";
-        draft: "draft";
         outbox: "outbox";
         scheduled: "scheduled";
     }>;
@@ -1010,9 +1010,9 @@ export declare const CLOSE_MEETING_SCHEMA: z.ZodObject<{
     startsAt: z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodString]>, z.ZodTransform<Date, string | Date>>;
     status: z.ZodNullable<z.ZodEnum<{
         completed: "completed";
+        canceled: "canceled";
         "in-progress": "in-progress";
         upcoming: "upcoming";
-        canceled: "canceled";
         "declined-by-org": "declined-by-org";
         "declined-by-lead": "declined-by-lead";
     }>>;
@@ -1127,9 +1127,9 @@ export declare const CLOSE_ACTIVITY_SCHEMA: z.ZodDiscriminatedUnion<[z.ZodObject
     sequenceSubscriptionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     status: z.ZodEnum<{
         error: "error";
+        draft: "draft";
         sent: "sent";
         inbox: "inbox";
-        draft: "draft";
         outbox: "outbox";
         scheduled: "scheduled";
     }>;
@@ -1186,9 +1186,9 @@ export declare const CLOSE_ACTIVITY_SCHEMA: z.ZodDiscriminatedUnion<[z.ZodObject
     startsAt: z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodString]>, z.ZodTransform<Date, string | Date>>;
     status: z.ZodNullable<z.ZodEnum<{
         completed: "completed";
+        canceled: "canceled";
         "in-progress": "in-progress";
         upcoming: "upcoming";
-        canceled: "canceled";
         "declined-by-org": "declined-by-org";
         "declined-by-lead": "declined-by-lead";
     }>>;
@@ -1269,9 +1269,9 @@ export declare const CLOSE_ACTIVITY_SCHEMA: z.ZodDiscriminatedUnion<[z.ZodObject
     }>;
     status: z.ZodEnum<{
         error: "error";
+        draft: "draft";
         sent: "sent";
         inbox: "inbox";
-        draft: "draft";
         outbox: "outbox";
         scheduled: "scheduled";
     }>;
@@ -1293,8 +1293,8 @@ export declare const CLOSE_ACTIVITY_SCHEMA: z.ZodDiscriminatedUnion<[z.ZodObject
 }, z.core.$catchall<z.ZodCustom<import("@automate.ax/codec").Encodable, import("@automate.ax/codec").Encodable>>>, z.ZodObject<{
     source: z.ZodNullable<z.ZodEnum<{
         email: "email";
-        ui: "ui";
         api: "api";
+        ui: "ui";
         import: "import";
         clipper: "clipper";
         suggestion: "suggestion";
@@ -1335,8 +1335,8 @@ export declare const CLOSE_ACTIVITY_SCHEMA: z.ZodDiscriminatedUnion<[z.ZodObject
     pinnedAt: z.ZodNullable<z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodString]>, z.ZodTransform<Date, string | Date>>>;
     source: z.ZodNullable<z.ZodEnum<{
         email: "email";
-        ui: "ui";
         api: "api";
+        ui: "ui";
         import: "import";
         clipper: "clipper";
         suggestion: "suggestion";
@@ -1409,9 +1409,9 @@ export declare const CLOSE_ACTIVITY_SCHEMA: z.ZodDiscriminatedUnion<[z.ZodObject
         sequenceSubscriptionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         status: z.ZodEnum<{
             error: "error";
+            draft: "draft";
             sent: "sent";
             inbox: "inbox";
-            draft: "draft";
             outbox: "outbox";
             scheduled: "scheduled";
         }>;
@@ -1505,9 +1505,9 @@ export declare const CLOSE_ACTIVITY_SCHEMA: z.ZodDiscriminatedUnion<[z.ZodObject
         sender: z.ZodNullable<z.ZodString>;
         status: z.ZodEnum<{
             error: "error";
+            draft: "draft";
             sent: "sent";
             inbox: "inbox";
-            draft: "draft";
             outbox: "outbox";
             scheduled: "scheduled";
         }>;
@@ -1762,8 +1762,8 @@ export declare const CLOSE_ACTIVITY_SCHEMA: z.ZodDiscriminatedUnion<[z.ZodObject
     sequenceSubscriptionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     source: z.ZodEnum<{
         email: "email";
-        ui: "ui";
         api: "api";
+        ui: "ui";
         import: "import";
         clipper: "clipper";
         suggestion: "suggestion";

package/dist/google-ads/api.d.ts

@@ -6,12 +6,21 @@ export declare const GOOGLE_ADS_SECRET_SCHEMA: z.ZodObject<{
     developerToken: z.ZodString;
     tokenType: z.ZodString;
 }, z.core.$strip>;
+export declare const GOOGLE_DATA_MANAGER_SECRET_SCHEMA: z.ZodObject<{
+    accessToken: z.ZodString;
+    tokenType: z.ZodString;
+}, z.core.$strip>;
 export interface GoogleAdsRequestOptions<TSchema extends z.ZodType> {
     body?: z.input<ReturnType<typeof z.json>>;
     loginCustomerId?: string;
     method?: "GET" | "POST";
     responseSchema: TSchema;
 }
+export interface GoogleDataManagerRequestOptions<TSchema extends z.ZodType> {
+    body?: z.input<ReturnType<typeof z.json>>;
+    method?: "GET" | "POST";
+    responseSchema: TSchema;
+}
 interface GoogleAdsApiErrorOptions {
     message?: string;
     providerStatus?: string;
@@ -34,6 +43,11 @@ export declare class GoogleAdsApiError extends Error {
 export declare function getGoogleAdsApi(secret: unknown): {
     request<TSchema extends z.ZodType>(path: string, options: GoogleAdsRequestOptions<TSchema>): Promise<z.output<TSchema>>;
 };
+/** Creates an authenticated Google Data Manager v1 REST client. */
+/** @param secret - Resolved Google OAuth credentials. */
+export declare function getGoogleDataManagerApi(secret: unknown): {
+    request<TSchema extends z.ZodType>(path: string, options: GoogleDataManagerRequestOptions<TSchema>): Promise<z.output<TSchema>>;
+};
 /** Normalizes a Google Ads customer ID for paths and headers. */
 /** @param value - Dashed or compact 10-digit customer ID. */
 export declare function normalizeGoogleAdsCustomerId(value: string): string;