@automate.ax/integration-contracts 0.55.0

package/dist/vercel/schemas.js

@@ -0,0 +1,335 @@
+import { z } from "zod";
+export const VERCEL_DEPLOYMENT_EVENT_TYPES = [
+    "deployment.created",
+    "deployment.ready",
+    "deployment.succeeded",
+    "deployment.error",
+    "deployment.canceled",
+    "deployment.promoted",
+];
+export const VERCEL_PROJECT_EVENT_TYPES = [
+    "project.created",
+    "project.removed",
+    "project.renamed",
+];
+export const VERCEL_PROJECT_ENVIRONMENT_VARIABLE_EVENT_TYPES = [
+    "project.env-variable.created",
+    "project.env-variable.updated",
+    "project.env-variable.deleted",
+];
+export const VERCEL_PROJECT_DOMAIN_EVENT_TYPES = [
+    "project.domain.created",
+    "project.domain.updated",
+    "project.domain.deleted",
+    "project.domain.verified",
+    "project.domain.unverified",
+    "project.domain.moved",
+];
+export const VERCEL_INTEGRATION_CONFIGURATION_EVENT_TYPES = [
+    "integration-configuration.permission-upgraded",
+    "integration-configuration.removed",
+    "integration-configuration.scope-change-confirmed",
+    "integration-configuration.transferred",
+];
+export const VERCEL_WEBHOOK_EVENT_TYPES = [
+    ...VERCEL_DEPLOYMENT_EVENT_TYPES,
+    ...VERCEL_PROJECT_EVENT_TYPES,
+    ...VERCEL_PROJECT_ENVIRONMENT_VARIABLE_EVENT_TYPES,
+    ...VERCEL_PROJECT_DOMAIN_EVENT_TYPES,
+    ...VERCEL_INTEGRATION_CONFIGURATION_EVENT_TYPES,
+];
+const VERCEL_TEAM_ACTOR_SCHEMA = z
+    .looseObject({
+    /** Stable Vercel team ID. */
+    id: z.string(),
+})
+    .catchall(z.json());
+const VERCEL_USER_ACTOR_SCHEMA = z
+    .looseObject({
+    /** Stable Vercel user ID. */
+    id: z.string(),
+})
+    .catchall(z.json());
+const VERCEL_ACTOR_SCHEMA = z.object({
+    /** Team that owns the affected resource, for team installations. */
+    team: VERCEL_TEAM_ACTOR_SCHEMA.nullable(),
+    /** User that initiated the event, when available. */
+    user: VERCEL_USER_ACTOR_SCHEMA.nullable(),
+});
+const VERCEL_PROJECT_REFERENCE_SCHEMA = z
+    .looseObject({
+    /** Stable Vercel project ID. */
+    id: z.string(),
+    /** Current project name, when included by Vercel. */
+    name: z.string().optional(),
+})
+    .catchall(z.json());
+const VERCEL_NAMED_PROJECT_REFERENCE_SCHEMA = VERCEL_PROJECT_REFERENCE_SCHEMA.extend({
+    /** Current project name. */
+    name: z.string(),
+});
+const VERCEL_DEPLOYMENT_REFERENCE_SCHEMA = z
+    .looseObject({
+    /** Stable Vercel deployment ID. */
+    id: z.string(),
+    /** Deployment or project name. */
+    name: z.string(),
+    /** Vercel deployment hostname. */
+    url: z.string(),
+})
+    .catchall(z.json());
+const VERCEL_DOMAIN_REFERENCE_SCHEMA = z
+    .looseObject({
+    /** Project domain name. */
+    name: z.string(),
+})
+    .catchall(z.json());
+const VERCEL_DEPLOYMENT_EVENT_PAYLOAD_SCHEMA = VERCEL_ACTOR_SCHEMA.extend({
+    /** Deployment affected by this event. */
+    deployment: VERCEL_DEPLOYMENT_REFERENCE_SCHEMA,
+    /** Project that owns the deployment. */
+    project: VERCEL_PROJECT_REFERENCE_SCHEMA,
+    /** Deployment target, when one was assigned. */
+    target: z.enum(["production", "staging"]).nullable().optional(),
+}).catchall(z.json());
+const VERCEL_PROJECT_EVENT_PAYLOAD_SCHEMA = VERCEL_ACTOR_SCHEMA.extend({
+    /** Project affected by this event. */
+    project: VERCEL_NAMED_PROJECT_REFERENCE_SCHEMA,
+}).catchall(z.json());
+const VERCEL_PROJECT_RENAMED_EVENT_PAYLOAD_SCHEMA = VERCEL_PROJECT_EVENT_PAYLOAD_SCHEMA.extend({
+    /** Project name before the rename. */
+    previousName: z.string(),
+});
+const VERCEL_PROJECT_ENVIRONMENT_VARIABLE_EVENT_PAYLOAD_SCHEMA = VERCEL_ACTOR_SCHEMA.extend({
+    /** Stable environment variable ID. */
+    envVarId: z.string(),
+    /** Stable project ID. */
+    projectId: z.string(),
+}).catchall(z.json());
+const VERCEL_PROJECT_ENVIRONMENT_VARIABLE_DELETED_EVENT_PAYLOAD_SCHEMA = VERCEL_PROJECT_ENVIRONMENT_VARIABLE_EVENT_PAYLOAD_SCHEMA.extend({
+    /** Stable environment variable ID, when Vercel still has it. */
+    envVarId: z.string().nullable(),
+});
+const VERCEL_PROJECT_DOMAIN_EVENT_PAYLOAD_SCHEMA = VERCEL_ACTOR_SCHEMA.extend({
+    /** Domain affected by this event. */
+    domain: VERCEL_DOMAIN_REFERENCE_SCHEMA,
+    /** Project that owns the domain. */
+    project: VERCEL_PROJECT_REFERENCE_SCHEMA,
+}).catchall(z.json());
+const VERCEL_PROJECT_DOMAIN_UPDATED_EVENT_PAYLOAD_SCHEMA = VERCEL_ACTOR_SCHEMA.extend({
+    /** Project-domain settings before the update. */
+    previous: z
+        .looseObject({
+        domain: z.string(),
+        gitBranch: z.string().nullable(),
+        redirect: z.string().nullable(),
+        redirectStatusCode: z.number().int().nullable(),
+    })
+        .catchall(z.json()),
+    /** Project-domain settings after the update. */
+    next: z
+        .looseObject({
+        domain: z.string(),
+        gitBranch: z.string().nullable(),
+        redirect: z.string().nullable(),
+        redirectStatusCode: z.number().int().nullable(),
+    })
+        .catchall(z.json()),
+    /** Project that owns the domain. */
+    project: VERCEL_PROJECT_REFERENCE_SCHEMA,
+});
+const VERCEL_PROJECT_DOMAIN_MOVED_EVENT_PAYLOAD_SCHEMA = VERCEL_ACTOR_SCHEMA.extend({
+    /** Domain moved between projects. */
+    domain: VERCEL_DOMAIN_REFERENCE_SCHEMA,
+    /** Project that previously owned the domain. */
+    from: z.looseObject({ projectId: z.string() }).catchall(z.json()),
+    /** Whether the move left a redirect on the previous project. */
+    isRedirect: z.boolean(),
+    /** Project that now owns the domain. */
+    to: z.looseObject({ projectId: z.string() }).catchall(z.json()),
+});
+const VERCEL_INTEGRATION_CONFIGURATION_SCHEMA = z
+    .looseObject({
+    /** Stable Vercel integration configuration ID. */
+    id: z.string(),
+    /** Project access mode selected for the installation. */
+    projectSelection: z.enum(["all", "selected"]).optional(),
+    /** Stable IDs of projects selected for the installation. */
+    projects: z.string().array().optional(),
+    /** OAuth scopes approved for the installation. */
+    scopes: z.string().array().optional(),
+})
+    .catchall(z.json());
+const VERCEL_INTEGRATION_CONFIGURATION_EVENT_PAYLOAD_SCHEMA = VERCEL_ACTOR_SCHEMA.extend({
+    /** Integration installation configuration affected by this event. */
+    configuration: VERCEL_INTEGRATION_CONFIGURATION_SCHEMA,
+}).catchall(z.json());
+const VERCEL_INTEGRATION_CONFIGURATION_PERMISSION_UPGRADED_EVENT_PAYLOAD_SCHEMA = VERCEL_INTEGRATION_CONFIGURATION_EVENT_PAYLOAD_SCHEMA.extend({
+    configuration: VERCEL_INTEGRATION_CONFIGURATION_SCHEMA.extend({
+        /** Current project access mode. */
+        projectSelection: z.enum(["all", "selected"]),
+        /** Project IDs currently available to the installation. */
+        projects: z.string().array(),
+    }),
+    /** Project IDs added to and removed from the installation. */
+    projects: z.object({
+        added: z.string().array(),
+        removed: z.string().array(),
+    }),
+});
+const VERCEL_INTEGRATION_CONFIGURATION_REMOVED_EVENT_PAYLOAD_SCHEMA = VERCEL_INTEGRATION_CONFIGURATION_EVENT_PAYLOAD_SCHEMA.extend({
+    configuration: VERCEL_INTEGRATION_CONFIGURATION_SCHEMA.extend({
+        /** Project IDs available before the installation was removed. */
+        projects: z.string().array(),
+    }),
+});
+const VERCEL_INTEGRATION_CONFIGURATION_SCOPE_CHANGE_CONFIRMED_EVENT_PAYLOAD_SCHEMA = VERCEL_INTEGRATION_CONFIGURATION_EVENT_PAYLOAD_SCHEMA.extend({
+    configuration: VERCEL_INTEGRATION_CONFIGURATION_SCHEMA.extend({
+        /** OAuth scopes approved after the change. */
+        scopes: z.string().array(),
+    }),
+});
+const VERCEL_INTEGRATION_CONFIGURATION_TRANSFERRED_EVENT_PAYLOAD_SCHEMA = z
+    .looseObject({
+    /** Integration installation configuration that was transferred. */
+    configuration: VERCEL_INTEGRATION_CONFIGURATION_SCHEMA,
+    /** Stable installation ID. */
+    installationId: z.string(),
+    /** New personal-account owner ID, when transferred to a user. */
+    newAccountId: z.string().nullable(),
+    /** New team owner ID, when transferred to a team. */
+    newTeamId: z.string().nullable(),
+    /** Previous personal-account owner ID, when transferred from a user. */
+    previousAccountId: z.string().nullable(),
+    /** Previous team owner ID, when transferred from a team. */
+    previousTeamId: z.string().nullable(),
+})
+    .catchall(z.json());
+/** Vercel deployment-created webhook. */
+export const VERCEL_DEPLOYMENT_CREATED_EVENT_SCHEMA = vercelWebhookEventSchema(z.literal("deployment.created"), VERCEL_DEPLOYMENT_EVENT_PAYLOAD_SCHEMA);
+/** Vercel deployment-ready webhook. */
+export const VERCEL_DEPLOYMENT_READY_EVENT_SCHEMA = vercelWebhookEventSchema(z.literal("deployment.ready"), VERCEL_DEPLOYMENT_EVENT_PAYLOAD_SCHEMA);
+/** Vercel deployment-succeeded webhook. */
+export const VERCEL_DEPLOYMENT_SUCCEEDED_EVENT_SCHEMA = vercelWebhookEventSchema(z.literal("deployment.succeeded"), VERCEL_DEPLOYMENT_EVENT_PAYLOAD_SCHEMA);
+/** Vercel deployment-error webhook. */
+export const VERCEL_DEPLOYMENT_FAILED_EVENT_SCHEMA = vercelWebhookEventSchema(z.literal("deployment.error"), VERCEL_DEPLOYMENT_EVENT_PAYLOAD_SCHEMA);
+/** Vercel deployment-canceled webhook. */
+export const VERCEL_DEPLOYMENT_CANCELED_EVENT_SCHEMA = vercelWebhookEventSchema(z.literal("deployment.canceled"), VERCEL_DEPLOYMENT_EVENT_PAYLOAD_SCHEMA);
+/** Vercel deployment-promoted webhook. */
+export const VERCEL_DEPLOYMENT_PROMOTED_EVENT_SCHEMA = vercelWebhookEventSchema(z.literal("deployment.promoted"), VERCEL_DEPLOYMENT_EVENT_PAYLOAD_SCHEMA);
+/** Vercel project-created webhook. */
+export const VERCEL_PROJECT_CREATED_EVENT_SCHEMA = vercelWebhookEventSchema(z.literal("project.created"), VERCEL_PROJECT_EVENT_PAYLOAD_SCHEMA);
+/** Vercel project-removed webhook. */
+export const VERCEL_PROJECT_REMOVED_EVENT_SCHEMA = vercelWebhookEventSchema(z.literal("project.removed"), VERCEL_PROJECT_EVENT_PAYLOAD_SCHEMA);
+/** Vercel project-renamed webhook. */
+export const VERCEL_PROJECT_RENAMED_EVENT_SCHEMA = vercelWebhookEventSchema(z.literal("project.renamed"), VERCEL_PROJECT_RENAMED_EVENT_PAYLOAD_SCHEMA);
+/** Vercel project environment-variable-created webhook. */
+export const VERCEL_PROJECT_ENVIRONMENT_VARIABLE_CREATED_EVENT_SCHEMA = vercelWebhookEventSchema(z.literal("project.env-variable.created"), VERCEL_PROJECT_ENVIRONMENT_VARIABLE_EVENT_PAYLOAD_SCHEMA);
+/** Vercel project environment-variable-updated webhook. */
+export const VERCEL_PROJECT_ENVIRONMENT_VARIABLE_UPDATED_EVENT_SCHEMA = vercelWebhookEventSchema(z.literal("project.env-variable.updated"), VERCEL_PROJECT_ENVIRONMENT_VARIABLE_EVENT_PAYLOAD_SCHEMA);
+/** Vercel project environment-variable-deleted webhook. */
+export const VERCEL_PROJECT_ENVIRONMENT_VARIABLE_DELETED_EVENT_SCHEMA = vercelWebhookEventSchema(z.literal("project.env-variable.deleted"), VERCEL_PROJECT_ENVIRONMENT_VARIABLE_DELETED_EVENT_PAYLOAD_SCHEMA);
+/** Vercel project-domain-created webhook. */
+export const VERCEL_PROJECT_DOMAIN_CREATED_EVENT_SCHEMA = vercelWebhookEventSchema(z.literal("project.domain.created"), VERCEL_PROJECT_DOMAIN_EVENT_PAYLOAD_SCHEMA);
+/** Vercel project-domain-updated webhook. */
+export const VERCEL_PROJECT_DOMAIN_UPDATED_EVENT_SCHEMA = vercelWebhookEventSchema(z.literal("project.domain.updated"), VERCEL_PROJECT_DOMAIN_UPDATED_EVENT_PAYLOAD_SCHEMA);
+/** Vercel project-domain-deleted webhook. */
+export const VERCEL_PROJECT_DOMAIN_DELETED_EVENT_SCHEMA = vercelWebhookEventSchema(z.literal("project.domain.deleted"), VERCEL_PROJECT_DOMAIN_EVENT_PAYLOAD_SCHEMA);
+/** Vercel project-domain-verified webhook. */
+export const VERCEL_PROJECT_DOMAIN_VERIFIED_EVENT_SCHEMA = vercelWebhookEventSchema(z.literal("project.domain.verified"), VERCEL_PROJECT_DOMAIN_EVENT_PAYLOAD_SCHEMA);
+/** Vercel project-domain-unverified webhook. */
+export const VERCEL_PROJECT_DOMAIN_UNVERIFIED_EVENT_SCHEMA = vercelWebhookEventSchema(z.literal("project.domain.unverified"), VERCEL_PROJECT_DOMAIN_EVENT_PAYLOAD_SCHEMA);
+/** Vercel project-domain-moved webhook. */
+export const VERCEL_PROJECT_DOMAIN_MOVED_EVENT_SCHEMA = vercelWebhookEventSchema(z.literal("project.domain.moved"), VERCEL_PROJECT_DOMAIN_MOVED_EVENT_PAYLOAD_SCHEMA);
+/** Vercel integration-configuration permission-upgraded webhook. */
+export const VERCEL_INTEGRATION_CONFIGURATION_PERMISSION_UPGRADED_EVENT_SCHEMA = vercelWebhookEventSchema(z.literal("integration-configuration.permission-upgraded"), VERCEL_INTEGRATION_CONFIGURATION_PERMISSION_UPGRADED_EVENT_PAYLOAD_SCHEMA);
+/** Vercel integration-configuration-removed webhook. */
+export const VERCEL_INTEGRATION_CONFIGURATION_REMOVED_EVENT_SCHEMA = vercelWebhookEventSchema(z.literal("integration-configuration.removed"), VERCEL_INTEGRATION_CONFIGURATION_REMOVED_EVENT_PAYLOAD_SCHEMA);
+/** Vercel integration-configuration scope-change-confirmed webhook. */
+export const VERCEL_INTEGRATION_CONFIGURATION_SCOPE_CHANGE_CONFIRMED_EVENT_SCHEMA = vercelWebhookEventSchema(z.literal("integration-configuration.scope-change-confirmed"), VERCEL_INTEGRATION_CONFIGURATION_SCOPE_CHANGE_CONFIRMED_EVENT_PAYLOAD_SCHEMA);
+/** Vercel integration-configuration-transferred webhook. */
+export const VERCEL_INTEGRATION_CONFIGURATION_TRANSFERRED_EVENT_SCHEMA = vercelWebhookEventSchema(z.literal("integration-configuration.transferred"), VERCEL_INTEGRATION_CONFIGURATION_TRANSFERRED_EVENT_PAYLOAD_SCHEMA);
+/** Supported Vercel deployment lifecycle webhook. */
+export const VERCEL_DEPLOYMENT_EVENT_SCHEMA = z.discriminatedUnion("type", [
+    VERCEL_DEPLOYMENT_CREATED_EVENT_SCHEMA,
+    VERCEL_DEPLOYMENT_READY_EVENT_SCHEMA,
+    VERCEL_DEPLOYMENT_SUCCEEDED_EVENT_SCHEMA,
+    VERCEL_DEPLOYMENT_FAILED_EVENT_SCHEMA,
+    VERCEL_DEPLOYMENT_CANCELED_EVENT_SCHEMA,
+    VERCEL_DEPLOYMENT_PROMOTED_EVENT_SCHEMA,
+]);
+/** Supported Vercel project lifecycle webhook. */
+export const VERCEL_PROJECT_EVENT_SCHEMA = z.discriminatedUnion("type", [
+    VERCEL_PROJECT_CREATED_EVENT_SCHEMA,
+    VERCEL_PROJECT_REMOVED_EVENT_SCHEMA,
+    VERCEL_PROJECT_RENAMED_EVENT_SCHEMA,
+]);
+/** Supported Vercel project environment-variable webhook. */
+export const VERCEL_PROJECT_ENVIRONMENT_VARIABLE_EVENT_SCHEMA = z.discriminatedUnion("type", [
+    VERCEL_PROJECT_ENVIRONMENT_VARIABLE_CREATED_EVENT_SCHEMA,
+    VERCEL_PROJECT_ENVIRONMENT_VARIABLE_UPDATED_EVENT_SCHEMA,
+    VERCEL_PROJECT_ENVIRONMENT_VARIABLE_DELETED_EVENT_SCHEMA,
+]);
+/** Supported Vercel project-domain webhook. */
+export const VERCEL_PROJECT_DOMAIN_EVENT_SCHEMA = z.discriminatedUnion("type", [
+    VERCEL_PROJECT_DOMAIN_CREATED_EVENT_SCHEMA,
+    VERCEL_PROJECT_DOMAIN_UPDATED_EVENT_SCHEMA,
+    VERCEL_PROJECT_DOMAIN_DELETED_EVENT_SCHEMA,
+    VERCEL_PROJECT_DOMAIN_VERIFIED_EVENT_SCHEMA,
+    VERCEL_PROJECT_DOMAIN_UNVERIFIED_EVENT_SCHEMA,
+    VERCEL_PROJECT_DOMAIN_MOVED_EVENT_SCHEMA,
+]);
+/** Supported Vercel integration-configuration webhook. */
+export const VERCEL_INTEGRATION_CONFIGURATION_EVENT_SCHEMA = z.discriminatedUnion("type", [
+    VERCEL_INTEGRATION_CONFIGURATION_PERMISSION_UPGRADED_EVENT_SCHEMA,
+    VERCEL_INTEGRATION_CONFIGURATION_REMOVED_EVENT_SCHEMA,
+    VERCEL_INTEGRATION_CONFIGURATION_SCOPE_CHANGE_CONFIRMED_EVENT_SCHEMA,
+    VERCEL_INTEGRATION_CONFIGURATION_TRANSFERRED_EVENT_SCHEMA,
+]);
+/** Every Vercel webhook handled by the integration. */
+export const VERCEL_WEBHOOK_EVENT_SCHEMA = z.discriminatedUnion("type", [
+    VERCEL_DEPLOYMENT_CREATED_EVENT_SCHEMA,
+    VERCEL_DEPLOYMENT_READY_EVENT_SCHEMA,
+    VERCEL_DEPLOYMENT_SUCCEEDED_EVENT_SCHEMA,
+    VERCEL_DEPLOYMENT_FAILED_EVENT_SCHEMA,
+    VERCEL_DEPLOYMENT_CANCELED_EVENT_SCHEMA,
+    VERCEL_DEPLOYMENT_PROMOTED_EVENT_SCHEMA,
+    VERCEL_PROJECT_CREATED_EVENT_SCHEMA,
+    VERCEL_PROJECT_REMOVED_EVENT_SCHEMA,
+    VERCEL_PROJECT_RENAMED_EVENT_SCHEMA,
+    VERCEL_PROJECT_ENVIRONMENT_VARIABLE_CREATED_EVENT_SCHEMA,
+    VERCEL_PROJECT_ENVIRONMENT_VARIABLE_UPDATED_EVENT_SCHEMA,
+    VERCEL_PROJECT_ENVIRONMENT_VARIABLE_DELETED_EVENT_SCHEMA,
+    VERCEL_PROJECT_DOMAIN_CREATED_EVENT_SCHEMA,
+    VERCEL_PROJECT_DOMAIN_UPDATED_EVENT_SCHEMA,
+    VERCEL_PROJECT_DOMAIN_DELETED_EVENT_SCHEMA,
+    VERCEL_PROJECT_DOMAIN_VERIFIED_EVENT_SCHEMA,
+    VERCEL_PROJECT_DOMAIN_UNVERIFIED_EVENT_SCHEMA,
+    VERCEL_PROJECT_DOMAIN_MOVED_EVENT_SCHEMA,
+    VERCEL_INTEGRATION_CONFIGURATION_PERMISSION_UPGRADED_EVENT_SCHEMA,
+    VERCEL_INTEGRATION_CONFIGURATION_REMOVED_EVENT_SCHEMA,
+    VERCEL_INTEGRATION_CONFIGURATION_SCOPE_CHANGE_CONFIRMED_EVENT_SCHEMA,
+    VERCEL_INTEGRATION_CONFIGURATION_TRANSFERRED_EVENT_SCHEMA,
+]);
+/**
+ * Creates one typed Vercel webhook envelope schema.
+ *
+ * @param type - Provider event discriminator schema.
+ * @param payload - Provider payload schema for the event.
+ */
+function vercelWebhookEventSchema(type, payload) {
+    return z
+        .looseObject({
+        /** When Vercel created the event, as Unix milliseconds. */
+        createdAt: z.number().int().nonnegative(),
+        /** Stable webhook delivery ID. */
+        id: z.string(),
+        /** Vercel region that emitted the event. */
+        region: z.string().nullable(),
+        /** Provider payload for this event type. */
+        payload,
+        /** Provider event discriminator. */
+        type,
+    })
+        .catchall(z.json());
+}

package/dist/whatsapp/api.d.ts

@@ -0,0 +1,62 @@
+import type { JsonObject } from "type-fest";
+import { z } from "zod";
+export declare const WHATSAPP_GRAPH_API_VERSION = "v26.0";
+/** Options for one authenticated WhatsApp Graph API request. */
+export interface WhatsAppApiRequestOptions<TSchema extends z.ZodType> {
+    /** JSON request body. */
+    body?: JsonObject;
+    /** HTTP verb. */
+    method?: "DELETE" | "GET" | "POST";
+    /** Schema that validates and types the successful response. */
+    responseSchema: TSchema;
+}
+/** Authenticated WhatsApp Business Platform helper for custom actions. */
+export interface WhatsAppApi {
+    /** Meta Business Portfolio ID that owns the connected assets. */
+    businessId: string;
+    /** Connected WhatsApp business phone-number ID. */
+    phoneNumberId: string;
+    /** Connected WhatsApp Business Account ID. */
+    wabaId: string;
+    /** Calls a Graph API path under the pinned platform version. */
+    request<TSchema extends z.ZodType>(path: string, options: WhatsAppApiRequestOptions<TSchema>): Promise<z.output<TSchema>>;
+}
+/** Structured error returned by Meta's Graph API. */
+export declare class WhatsAppApiError extends Error {
+    readonly code?: number;
+    readonly details?: string;
+    readonly fbtraceId?: string;
+    readonly retryAfter?: number;
+    readonly status: number;
+    readonly subcode?: number;
+    readonly type?: string;
+    /**
+     * Creates a structured Graph API error.
+     *
+     * @param options - Provider and transport error details.
+     * @param options.code - Meta Graph API error code.
+     * @param options.details - WhatsApp-specific failure details.
+     * @param options.fbtraceId - Meta trace identifier.
+     * @param options.message - Human-readable provider message.
+     * @param options.retryAfter - Retry delay in seconds.
+     * @param options.status - HTTP response status.
+     * @param options.subcode - Meta Graph API error subcode.
+     * @param options.type - Meta error type.
+     */
+    constructor(options: {
+        code?: number;
+        details?: string;
+        fbtraceId?: string;
+        message: string;
+        retryAfter?: number;
+        status: number;
+        subcode?: number;
+        type?: string;
+    });
+}
+/**
+ * Creates an authenticated WhatsApp Business Platform client.
+ *
+ * @param secret - Resolved WhatsApp integration secret.
+ */
+export declare function getWhatsAppApi(secret: Record<string, unknown>): WhatsAppApi;

package/dist/whatsapp/api.js

@@ -0,0 +1,121 @@
+import { z } from "zod";
+export const WHATSAPP_GRAPH_API_VERSION = "v26.0";
+const WHATSAPP_GRAPH_API_ORIGIN = "https://graph.facebook.com";
+const WHATSAPP_SECRET_SCHEMA = z.object({
+    accessToken: z.string().min(1),
+    businessId: z.string().min(1),
+    phoneNumberId: z.string().min(1),
+    wabaId: z.string().min(1),
+});
+const WHATSAPP_ERROR_SCHEMA = z.looseObject({
+    code: z.number().int().optional(),
+    error_data: z
+        .looseObject({
+        details: z.string().optional(),
+        messaging_product: z.string().optional(),
+    })
+        .optional(),
+    error_subcode: z.number().int().optional(),
+    fbtrace_id: z.string().optional(),
+    message: z.string().optional(),
+    type: z.string().optional(),
+});
+/** Structured error returned by Meta's Graph API. */
+export class WhatsAppApiError extends Error {
+    code;
+    details;
+    fbtraceId;
+    retryAfter;
+    status;
+    subcode;
+    type;
+    /**
+     * Creates a structured Graph API error.
+     *
+     * @param options - Provider and transport error details.
+     * @param options.code - Meta Graph API error code.
+     * @param options.details - WhatsApp-specific failure details.
+     * @param options.fbtraceId - Meta trace identifier.
+     * @param options.message - Human-readable provider message.
+     * @param options.retryAfter - Retry delay in seconds.
+     * @param options.status - HTTP response status.
+     * @param options.subcode - Meta Graph API error subcode.
+     * @param options.type - Meta error type.
+     */
+    constructor(options) {
+        super(options.message);
+        this.name = "WhatsAppApiError";
+        this.code = options.code;
+        this.details = options.details;
+        this.fbtraceId = options.fbtraceId;
+        this.retryAfter = options.retryAfter;
+        this.status = options.status;
+        this.subcode = options.subcode;
+        this.type = options.type;
+    }
+}
+/**
+ * Creates an authenticated WhatsApp Business Platform client.
+ *
+ * @param secret - Resolved WhatsApp integration secret.
+ */
+export function getWhatsAppApi(secret) {
+    const { accessToken, businessId, phoneNumberId, wabaId } = WHATSAPP_SECRET_SCHEMA.parse(secret);
+    return {
+        businessId,
+        phoneNumberId,
+        wabaId,
+        request: async (path, options) => {
+            if (!/^\/[A-Za-z0-9_.,?=&/-]+$/.test(path)) {
+                throw new Error("WhatsApp Graph API paths must be relative.");
+            }
+            const response = await fetch(`${WHATSAPP_GRAPH_API_ORIGIN}/${WHATSAPP_GRAPH_API_VERSION}${path}`, {
+                body: options.body ? JSON.stringify(options.body) : undefined,
+                headers: {
+                    Accept: "application/json",
+                    Authorization: `Bearer ${accessToken}`,
+                    ...(options.body && { "Content-Type": "application/json" }),
+                },
+                method: options.method ?? (options.body ? "POST" : "GET"),
+            });
+            const payload = await response.json();
+            if (!response.ok)
+                throw toWhatsAppApiError(response, payload);
+            return options.responseSchema.parse(payload);
+        },
+    };
+}
+/**
+ * Converts an unsuccessful Graph response into a structured error.
+ *
+ * @param response - Unsuccessful HTTP response.
+ * @param payload - Parsed Graph API payload.
+ */
+function toWhatsAppApiError(response, payload) {
+    const error = z
+        .looseObject({ error: WHATSAPP_ERROR_SCHEMA.optional() })
+        .safeParse(payload);
+    const providerError = error.success ? error.data.error : undefined;
+    return new WhatsAppApiError({
+        code: providerError?.code,
+        details: providerError?.error_data?.details,
+        fbtraceId: providerError?.fbtrace_id,
+        message: providerError?.message ??
+            `WhatsApp Graph API request failed (${response.status}).`,
+        retryAfter: parseRetryAfter(response.headers.get("Retry-After")),
+        status: response.status,
+        subcode: providerError?.error_subcode,
+        type: providerError?.type,
+    });
+}
+/**
+ * Parses Meta's integer retry delay header.
+ *
+ * @param value - Raw `Retry-After` value.
+ */
+function parseRetryAfter(value) {
+    if (value === null)
+        return undefined;
+    const seconds = Number(value);
+    return Number.isFinite(seconds) ? seconds : undefined;
+}