@automate.ax/integration-contracts 0.143.8 → 0.144.0

package/src/calendly/schemas.ts

@@ -0,0 +1,450 @@
+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",
+] as const
+
+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/src/google-ads/api.ts

@@ -2,6 +2,8 @@ import * as z from "zod"
 
 const GOOGLE_ADS_API_ORIGIN = "https://googleads.googleapis.com"
 const GOOGLE_ADS_API_VERSION = "v25"
+const GOOGLE_DATA_MANAGER_API_ORIGIN = "https://datamanager.googleapis.com"
+const GOOGLE_DATA_MANAGER_API_VERSION = "v1"
 
 export const GOOGLE_ADS_CUSTOMER_ID_SCHEMA = z
   .string()
@@ -19,6 +21,11 @@ export const GOOGLE_ADS_SECRET_SCHEMA = z.object({
   tokenType: z.string().min(1),
 })
 
+export const GOOGLE_DATA_MANAGER_SECRET_SCHEMA = z.object({
+  accessToken: z.string().min(1),
+  tokenType: z.string().min(1),
+})
+
 const GOOGLE_ADS_FAILURE_SCHEMA = z.looseObject({
   error: z
     .looseObject({
@@ -36,6 +43,12 @@ export interface GoogleAdsRequestOptions<TSchema extends z.ZodType> {
   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
@@ -133,6 +146,66 @@ export function getGoogleAdsApi(secret: unknown) {
   }
 }
 
+/** Creates an authenticated Google Data Manager v1 REST client. */
+/** @param secret - Resolved Google OAuth credentials. */
+export function getGoogleDataManagerApi(secret: unknown) {
+  const credentials = GOOGLE_DATA_MANAGER_SECRET_SCHEMA.parse(secret)
+
+  return {
+    async request<TSchema extends z.ZodType>(
+      path: string,
+      options: GoogleDataManagerRequestOptions<TSchema>,
+    ): Promise<z.output<TSchema>> {
+      const normalizedPath = path.replace(/^\/+/, "")
+      if (
+        !normalizedPath ||
+        normalizedPath.includes("://") ||
+        normalizedPath.includes("\\")
+      ) {
+        throw new TypeError("Google Data Manager API paths must be relative.")
+      }
+      const url = new URL(
+        `${GOOGLE_DATA_MANAGER_API_VERSION}/${normalizedPath}`,
+        `${GOOGLE_DATA_MANAGER_API_ORIGIN}/`,
+      )
+      if (url.origin !== GOOGLE_DATA_MANAGER_API_ORIGIN) {
+        throw new TypeError(
+          "Google Data Manager API paths must remain on datamanager.googleapis.com.",
+        )
+      }
+
+      const headers = new Headers({
+        Accept: "application/json",
+        Authorization: `Bearer ${credentials.accessToken}`,
+      })
+      if (options.body !== undefined) {
+        headers.set("Content-Type", "application/json")
+      }
+
+      const response = await fetch(url, {
+        body:
+          options.body === undefined ? undefined : JSON.stringify(options.body),
+        headers,
+        method: options.method ?? (options.body === undefined ? "GET" : "POST"),
+      })
+      const payload = parseGoogleAdsJson(await response.text())
+      if (!response.ok) {
+        const failure = GOOGLE_ADS_FAILURE_SCHEMA.safeParse(payload)
+        throw new GoogleAdsApiError({
+          message: failure.success ? failure.data.error?.message : undefined,
+          providerStatus: failure.success
+            ? failure.data.error?.status
+            : undefined,
+          requestId: response.headers.get("request-id") ?? undefined,
+          retryAfter: response.headers.get("retry-after") ?? undefined,
+          status: response.status,
+        })
+      }
+      return options.responseSchema.parse(payload)
+    },
+  }
+}
+
 /** Normalizes a Google Ads customer ID for paths and headers. */
 /** @param value - Dashed or compact 10-digit customer ID. */
 export function normalizeGoogleAdsCustomerId(value: string) {

package/src/triggers.ts

@@ -10,6 +10,7 @@ import type { discordTriggerContracts } from "./discord"
 import type { closeTriggerContracts } from "./close"
 import type { cloudflareTriggerContracts } from "./cloudflare"
 import type { clickUpTriggerContracts } from "./clickup"
+import type { calendlyTriggerContracts } from "./calendly"
 import type { githubTriggerContracts } from "./github"
 import type { gmailTriggerContracts } from "./gmail"
 import type { googleCalendarTriggerContracts } from "./google-calendar"
@@ -46,6 +47,7 @@ export type TriggerContractMap = typeof airtableTriggerContracts &
   typeof discordTriggerContracts &
   typeof closeTriggerContracts &
   typeof clickUpTriggerContracts &
+  typeof calendlyTriggerContracts &
   typeof cloudflareTriggerContracts &
   typeof githubTriggerContracts &
   typeof gmailTriggerContracts &