@automate.ax/integration-contracts 0.107.0 → 0.109.0

package/dist/airtable/schemas.js

@@ -32,7 +32,28 @@ const AIRTABLE_VIEW_CHANGE_SCHEMA = z.looseObject({
         .optional(),
     destroyedRecordIds: z.string().array().optional(),
 });
+const AIRTABLE_FIELD_DEFINITION_SCHEMA = z.object({
+    name: z.string(),
+    type: z.string(),
+});
+const AIRTABLE_FIELD_CHANGE_SCHEMA = z.looseObject({
+    current: AIRTABLE_FIELD_DEFINITION_SCHEMA.partial(),
+    previous: AIRTABLE_FIELD_DEFINITION_SCHEMA.partial().optional(),
+});
+const AIRTABLE_TABLE_METADATA_SCHEMA = z.object({
+    description: z.string().nullable(),
+    name: z.string(),
+});
 const AIRTABLE_TABLE_CHANGE_SCHEMA = z.looseObject({
+    changedFieldsById: z
+        .record(z.string(), AIRTABLE_FIELD_CHANGE_SCHEMA)
+        .optional(),
+    changedMetadata: z
+        .looseObject({
+        current: AIRTABLE_TABLE_METADATA_SCHEMA.partial(),
+        previous: AIRTABLE_TABLE_METADATA_SCHEMA.partial(),
+    })
+        .optional(),
     changedRecordsById: z
         .record(z.string(), AIRTABLE_CHANGED_RECORD_SCHEMA)
         .optional(),
@@ -42,8 +63,17 @@ const AIRTABLE_TABLE_CHANGE_SCHEMA = z.looseObject({
     createdRecordsById: z
         .record(z.string(), AIRTABLE_CREATED_RECORD_SCHEMA)
         .optional(),
+    createdFieldsById: z
+        .record(z.string(), AIRTABLE_FIELD_DEFINITION_SCHEMA)
+        .optional(),
+    destroyedFieldIds: z.string().array().optional(),
     destroyedRecordIds: z.string().array().optional(),
 });
+const AIRTABLE_CREATED_TABLE_SCHEMA = z.looseObject({
+    fieldsById: z.record(z.string(), AIRTABLE_FIELD_DEFINITION_SCHEMA).optional(),
+    metadata: AIRTABLE_TABLE_METADATA_SCHEMA.optional(),
+    recordsById: z.record(z.string(), AIRTABLE_CREATED_RECORD_SCHEMA).optional(),
+});
 /** One provider-native Airtable webhook transaction payload. */
 export const AIRTABLE_WEBHOOK_PAYLOAD_SCHEMA = z
     .looseObject({
@@ -52,12 +82,62 @@ export const AIRTABLE_WEBHOOK_PAYLOAD_SCHEMA = z
     changedTablesById: z
         .record(z.string(), AIRTABLE_TABLE_CHANGE_SCHEMA)
         .optional(),
+    createdTablesById: z
+        .record(z.string(), AIRTABLE_CREATED_TABLE_SCHEMA)
+        .optional(),
     code: z.string().optional(),
     error: z.literal(true).optional(),
+    destroyedTableIds: z.string().array().optional(),
     payloadFormat: z.string(),
     timestamp: z.iso.datetime({ offset: true }),
 })
     .catchall(z.json());
+export const AIRTABLE_BASE_EVENT_SCHEMA = z.object({
+    /** Airtable base that emitted the transaction. */
+    baseId: z.string(),
+    /** Complete provider webhook transaction. */
+    event: AIRTABLE_WEBHOOK_PAYLOAD_SCHEMA,
+    /** Time at which Airtable committed the transaction. */
+    occurredAt: z.iso.datetime({ offset: true }),
+    /** Airtable system that caused the transaction. */
+    source: z.string(),
+    /** Provider-specific actor or source details. */
+    sourceMetadata: z.record(z.string(), z.json()).optional(),
+    /** Base-scoped transaction number assigned by Airtable. */
+    transactionNumber: z.number().int().nonnegative(),
+});
+const AIRTABLE_TABLE_EVENT_SCHEMA = AIRTABLE_BASE_EVENT_SCHEMA.extend({
+    /** Stable Airtable table ID. */
+    tableId: z.string(),
+});
+export const AIRTABLE_TABLE_CREATED_EVENT_SCHEMA = AIRTABLE_TABLE_EVENT_SCHEMA.extend({
+    /** Field definitions keyed by stable field ID. */
+    fields: z.record(z.string(), AIRTABLE_FIELD_DEFINITION_SCHEMA),
+    /** Created table metadata when included by Airtable. */
+    metadata: AIRTABLE_TABLE_METADATA_SCHEMA.optional(),
+});
+export const AIRTABLE_TABLE_UPDATED_EVENT_SCHEMA = AIRTABLE_TABLE_EVENT_SCHEMA.extend({
+    /** Current table metadata fields changed by the transaction. */
+    current: AIRTABLE_TABLE_METADATA_SCHEMA.partial(),
+    /** Previous table metadata fields changed by the transaction. */
+    previous: AIRTABLE_TABLE_METADATA_SCHEMA.partial(),
+});
+export const AIRTABLE_TABLE_DELETED_EVENT_SCHEMA = AIRTABLE_TABLE_EVENT_SCHEMA;
+const AIRTABLE_FIELD_EVENT_SCHEMA = AIRTABLE_TABLE_EVENT_SCHEMA.extend({
+    /** Stable Airtable field ID. */
+    fieldId: z.string(),
+});
+export const AIRTABLE_FIELD_CREATED_EVENT_SCHEMA = AIRTABLE_FIELD_EVENT_SCHEMA.extend({
+    /** Created field definition. */
+    field: AIRTABLE_FIELD_DEFINITION_SCHEMA,
+});
+export const AIRTABLE_FIELD_UPDATED_EVENT_SCHEMA = AIRTABLE_FIELD_EVENT_SCHEMA.extend({
+    /** Current field definition values changed by the transaction. */
+    current: AIRTABLE_FIELD_DEFINITION_SCHEMA.partial(),
+    /** Previous field definition values changed by the transaction. */
+    previous: AIRTABLE_FIELD_DEFINITION_SCHEMA.partial().optional(),
+});
+export const AIRTABLE_FIELD_DELETED_EVENT_SCHEMA = AIRTABLE_FIELD_EVENT_SCHEMA;
 const AIRTABLE_RECORD_EVENT_SCHEMA = z.object({
     /** Airtable base containing the affected record. */
     baseId: z.string(),
@@ -99,7 +179,14 @@ export const AIRTABLE_RECORD_MOVED_OUT_OF_VIEW_EVENT_SCHEMA = AIRTABLE_RECORD_EV
     /** Stable ID of the view the record exited. */
     viewId: z.string(),
 });
-export const AIRTABLE_RECORD_EVENT_TYPES = [
+export const AIRTABLE_EVENT_TYPES = [
+    "airtable.base.event",
+    "airtable.table.created",
+    "airtable.table.updated",
+    "airtable.table.deleted",
+    "airtable.field.created",
+    "airtable.field.updated",
+    "airtable.field.deleted",
     "airtable.record.created",
     "airtable.record.updated",
     "airtable.record.deleted",
@@ -107,78 +194,175 @@ export const AIRTABLE_RECORD_EVENT_TYPES = [
     "airtable.record.movedOutOfView",
 ];
 /**
- * Expands one Airtable webhook transaction into semantic record events.
+ * Expands one Airtable webhook transaction into broad and semantic events.
  *
  * @param value - Untrusted provider payload returned by Airtable.
  * @param baseId - Stable ID of the base that owns the webhook.
  */
-export function normalizeAirtableRecordEvents(value, baseId) {
+export function normalizeAirtableEvents(value, baseId) {
     const event = AIRTABLE_WEBHOOK_PAYLOAD_SCHEMA.parse(value);
-    return Object.entries(event.changedTablesById ?? {}).flatMap(([tableId, table]) => [
-        ...Object.entries(table.createdRecordsById ?? {}).map(([recordId, record]) => ({
-            eventType: "airtable.record.created",
-            payload: AIRTABLE_RECORD_CREATED_EVENT_SCHEMA.parse({
-                ...recordEventBase(event, baseId, tableId, recordId),
-                createdAt: record.createdTime,
-                fields: record.cellValuesByFieldId,
-            }),
-        })),
-        ...Object.entries(table.changedRecordsById ?? {}).map(([recordId, record]) => ({
-            eventType: "airtable.record.updated",
-            payload: AIRTABLE_RECORD_UPDATED_EVENT_SCHEMA.parse({
-                ...recordEventBase(event, baseId, tableId, recordId),
-                changedFieldIds: Object.keys(record.current.cellValuesByFieldId),
-                fields: {
-                    ...record.unchanged?.cellValuesByFieldId,
-                    ...record.current.cellValuesByFieldId,
-                },
-                previousFields: {
-                    ...record.unchanged?.cellValuesByFieldId,
-                    ...record.previous?.cellValuesByFieldId,
-                },
-            }),
-        })),
-        ...(table.destroyedRecordIds ?? []).map((recordId) => ({
-            eventType: "airtable.record.deleted",
-            payload: AIRTABLE_RECORD_DELETED_EVENT_SCHEMA.parse(recordEventBase(event, baseId, tableId, recordId)),
+    return [
+        {
+            eventType: "airtable.base.event",
+            payload: AIRTABLE_BASE_EVENT_SCHEMA.parse(baseEventBase(event, baseId)),
+        },
+        ...Object.entries(event.createdTablesById ?? {}).flatMap(([tableId, table]) => [
+            {
+                eventType: "airtable.table.created",
+                payload: AIRTABLE_TABLE_CREATED_EVENT_SCHEMA.parse({
+                    ...tableEventBase(event, baseId, tableId),
+                    fields: table.fieldsById ?? {},
+                    metadata: table.metadata,
+                }),
+            },
+            ...Object.entries(table.fieldsById ?? {}).map(([fieldId, field]) => ({
+                eventType: "airtable.field.created",
+                payload: AIRTABLE_FIELD_CREATED_EVENT_SCHEMA.parse({
+                    ...fieldEventBase(event, baseId, tableId, fieldId),
+                    field,
+                }),
+            })),
+            ...Object.entries(table.recordsById ?? {}).map(([recordId, record]) => ({
+                eventType: "airtable.record.created",
+                payload: AIRTABLE_RECORD_CREATED_EVENT_SCHEMA.parse({
+                    ...recordEventBase(event, baseId, tableId, recordId),
+                    createdAt: record.createdTime,
+                    fields: record.cellValuesByFieldId,
+                }),
+            })),
+        ]),
+        ...(event.destroyedTableIds ?? []).map((tableId) => ({
+            eventType: "airtable.table.deleted",
+            payload: AIRTABLE_TABLE_DELETED_EVENT_SCHEMA.parse(tableEventBase(event, baseId, tableId)),
         })),
-        ...Object.entries(table.changedViewsById ?? {}).flatMap(([viewId, view]) => [
-            ...Object.entries(view.createdRecordsById ?? {}).map(([recordId, record]) => ({
-                eventType: "airtable.record.movedIntoView",
-                payload: AIRTABLE_RECORD_MOVED_INTO_VIEW_EVENT_SCHEMA.parse({
+        ...Object.entries(event.changedTablesById ?? {}).flatMap(([tableId, table]) => [
+            ...(table.changedMetadata
+                ? [
+                    {
+                        eventType: "airtable.table.updated",
+                        payload: AIRTABLE_TABLE_UPDATED_EVENT_SCHEMA.parse({
+                            ...tableEventBase(event, baseId, tableId),
+                            current: table.changedMetadata.current,
+                            previous: table.changedMetadata.previous,
+                        }),
+                    },
+                ]
+                : []),
+            ...Object.entries(table.createdFieldsById ?? {}).map(([fieldId, field]) => ({
+                eventType: "airtable.field.created",
+                payload: AIRTABLE_FIELD_CREATED_EVENT_SCHEMA.parse({
+                    ...fieldEventBase(event, baseId, tableId, fieldId),
+                    field,
+                }),
+            })),
+            ...Object.entries(table.changedFieldsById ?? {}).map(([fieldId, field]) => ({
+                eventType: "airtable.field.updated",
+                payload: AIRTABLE_FIELD_UPDATED_EVENT_SCHEMA.parse({
+                    ...fieldEventBase(event, baseId, tableId, fieldId),
+                    current: field.current,
+                    previous: field.previous,
+                }),
+            })),
+            ...(table.destroyedFieldIds ?? []).map((fieldId) => ({
+                eventType: "airtable.field.deleted",
+                payload: AIRTABLE_FIELD_DELETED_EVENT_SCHEMA.parse(fieldEventBase(event, baseId, tableId, fieldId)),
+            })),
+            ...Object.entries(table.createdRecordsById ?? {}).map(([recordId, record]) => ({
+                eventType: "airtable.record.created",
+                payload: AIRTABLE_RECORD_CREATED_EVENT_SCHEMA.parse({
                     ...recordEventBase(event, baseId, tableId, recordId),
                     createdAt: record.createdTime,
                     fields: record.cellValuesByFieldId,
-                    viewId,
                 }),
             })),
-            ...(view.destroyedRecordIds ?? []).map((recordId) => ({
-                eventType: "airtable.record.movedOutOfView",
-                payload: AIRTABLE_RECORD_MOVED_OUT_OF_VIEW_EVENT_SCHEMA.parse({
+            ...Object.entries(table.changedRecordsById ?? {}).map(([recordId, record]) => ({
+                eventType: "airtable.record.updated",
+                payload: AIRTABLE_RECORD_UPDATED_EVENT_SCHEMA.parse({
                     ...recordEventBase(event, baseId, tableId, recordId),
-                    viewId,
+                    changedFieldIds: Object.keys(record.current.cellValuesByFieldId),
+                    fields: {
+                        ...record.unchanged?.cellValuesByFieldId,
+                        ...record.current.cellValuesByFieldId,
+                    },
+                    previousFields: {
+                        ...record.unchanged?.cellValuesByFieldId,
+                        ...record.previous?.cellValuesByFieldId,
+                    },
                 }),
             })),
+            ...(table.destroyedRecordIds ?? []).map((recordId) => ({
+                eventType: "airtable.record.deleted",
+                payload: AIRTABLE_RECORD_DELETED_EVENT_SCHEMA.parse(recordEventBase(event, baseId, tableId, recordId)),
+            })),
+            ...Object.entries(table.changedViewsById ?? {}).flatMap(([viewId, view]) => [
+                ...Object.entries(view.createdRecordsById ?? {}).map(([recordId, record]) => ({
+                    eventType: "airtable.record.movedIntoView",
+                    payload: AIRTABLE_RECORD_MOVED_INTO_VIEW_EVENT_SCHEMA.parse({
+                        ...recordEventBase(event, baseId, tableId, recordId),
+                        createdAt: record.createdTime,
+                        fields: record.cellValuesByFieldId,
+                        viewId,
+                    }),
+                })),
+                ...(view.destroyedRecordIds ?? []).map((recordId) => ({
+                    eventType: "airtable.record.movedOutOfView",
+                    payload: AIRTABLE_RECORD_MOVED_OUT_OF_VIEW_EVENT_SCHEMA.parse({
+                        ...recordEventBase(event, baseId, tableId, recordId),
+                        viewId,
+                    }),
+                })),
+            ]),
         ]),
-    ]);
+    ];
 }
 /**
- * Builds fields shared by every normalized Airtable record event.
+ * Builds fields shared by every event in one Airtable transaction.
  *
  * @param event - Parsed provider transaction.
- * @param baseId - Base containing the changed record.
- * @param tableId - Table containing the changed record.
- * @param recordId - Stable ID of the changed record.
+ * @param baseId - Stable Airtable base ID.
  */
-function recordEventBase(event, baseId, tableId, recordId) {
+function baseEventBase(event, baseId) {
     return {
         baseId,
         event,
         occurredAt: event.timestamp,
-        recordId,
         source: event.actionMetadata.source,
         sourceMetadata: event.actionMetadata.sourceMetadata,
-        tableId,
         transactionNumber: event.baseTransactionNumber,
     };
 }
+/**
+ * Adds a stable table ID to the shared Airtable event fields.
+ *
+ * @param event - Parsed provider transaction.
+ * @param baseId - Stable Airtable base ID.
+ * @param tableId - Stable Airtable table ID.
+ */
+function tableEventBase(event, baseId, tableId) {
+    return { ...baseEventBase(event, baseId), tableId };
+}
+/**
+ * Adds stable table and field IDs to the shared Airtable event fields.
+ *
+ * @param event - Parsed provider transaction.
+ * @param baseId - Stable Airtable base ID.
+ * @param tableId - Stable Airtable table ID.
+ * @param fieldId - Stable Airtable field ID.
+ */
+function fieldEventBase(event, baseId, tableId, fieldId) {
+    return { ...tableEventBase(event, baseId, tableId), fieldId };
+}
+/**
+ * Builds fields shared by every normalized Airtable record event.
+ *
+ * @param event - Parsed provider transaction.
+ * @param baseId - Base containing the changed record.
+ * @param tableId - Table containing the changed record.
+ * @param recordId - Stable ID of the changed record.
+ */
+function recordEventBase(event, baseId, tableId, recordId) {
+    return {
+        ...tableEventBase(event, baseId, tableId),
+        recordId,
+    };
+}

package/dist/brevo/api.d.ts

@@ -1,4 +1,45 @@
 import * as z from "zod";
+/** Provider rate-limit values returned with a Brevo response. */
+export interface BrevoRateLimitMetadata {
+    /** Maximum requests allowed in the current window. */
+    limit?: number;
+    /** Requests remaining in the current window. */
+    remaining?: number;
+    /** Seconds until the current window resets. */
+    reset?: number;
+}
+/** Structured failure returned by the Brevo API. */
+export declare class BrevoApiError extends Error {
+    /** Provider error classification. */
+    readonly code?: string;
+    /** API path that failed. */
+    readonly path: string;
+    /** Provider rate-limit metadata. */
+    readonly rateLimit: BrevoRateLimitMetadata;
+    /** Delay in seconds before the request should be retried. */
+    readonly retryAfter?: number;
+    /** HTTP status returned by Brevo. */
+    readonly status: number;
+    /**
+     * Creates a structured Brevo provider error.
+     *
+     * @param options - Provider and transport failure details.
+     * @param options.code - Provider error classification.
+     * @param options.message - Human-readable provider failure.
+     * @param options.path - API path that failed.
+     * @param options.rateLimit - Provider rate-limit metadata.
+     * @param options.retryAfter - Provider retry delay in seconds.
+     * @param options.status - HTTP status.
+     */
+    constructor(options: {
+        code?: string;
+        message: string;
+        path: string;
+        rateLimit: BrevoRateLimitMetadata;
+        retryAfter?: number;
+        status: number;
+    });
+}
 /** Options accepted by the authenticated Brevo request helper. */
 export interface BrevoRequestOptions extends RequestInit {
     /** Query parameters appended to the request URL. */

package/dist/brevo/api.js

@@ -8,6 +8,39 @@ const BREVO_ERROR_SCHEMA = z.looseObject({
     code: z.string().optional(),
     message: z.string().optional(),
 });
+/** Structured failure returned by the Brevo API. */
+export class BrevoApiError extends Error {
+    /** Provider error classification. */
+    code;
+    /** API path that failed. */
+    path;
+    /** Provider rate-limit metadata. */
+    rateLimit;
+    /** Delay in seconds before the request should be retried. */
+    retryAfter;
+    /** HTTP status returned by Brevo. */
+    status;
+    /**
+     * Creates a structured Brevo provider error.
+     *
+     * @param options - Provider and transport failure details.
+     * @param options.code - Provider error classification.
+     * @param options.message - Human-readable provider failure.
+     * @param options.path - API path that failed.
+     * @param options.rateLimit - Provider rate-limit metadata.
+     * @param options.retryAfter - Provider retry delay in seconds.
+     * @param options.status - HTTP status.
+     */
+    constructor(options) {
+        super(`Brevo ${options.path} failed: ${options.message}`);
+        this.name = "BrevoApiError";
+        this.code = options.code;
+        this.path = options.path;
+        this.rateLimit = options.rateLimit;
+        this.retryAfter = options.retryAfter;
+        this.status = options.status;
+    }
+}
 /**
  * Creates a small authenticated Brevo REST client.
  *
@@ -46,10 +79,21 @@ export function getBrevoApi(secret) {
             const response = await fetch(url, { ...requestInit, headers });
             if (response.ok)
                 return response;
-            const error = BREVO_ERROR_SCHEMA.safeParse(await response.json().catch(() => ({})));
-            throw new Error(error.success && error.data.message
-                ? `Brevo API error (${response.status}): ${error.data.message}`
-                : `Brevo API request failed with status ${response.status}.`);
+            const responseText = await response.text();
+            const error = BREVO_ERROR_SCHEMA.safeParse(parseJson(responseText));
+            throw new BrevoApiError({
+                code: error.success ? error.data.code : undefined,
+                message: (error.success ? error.data.message : undefined) ??
+                    (responseText.trim() || `HTTP ${response.status}`),
+                path: `${url.pathname}${url.search}`,
+                rateLimit: {
+                    limit: parseNumberHeader(response.headers, "x-sib-ratelimit-limit"),
+                    remaining: parseNumberHeader(response.headers, "x-sib-ratelimit-remaining"),
+                    reset: parseNumberHeader(response.headers, "x-sib-ratelimit-reset"),
+                },
+                retryAfter: parseNumberHeader(response.headers, "retry-after"),
+                status: response.status,
+            });
         },
     };
 }
@@ -62,3 +106,29 @@ export function getBrevoApi(secret) {
 export async function parseBrevoResponse(response, schema) {
     return schema.parse(await response.json());
 }
+/**
+ * Parses provider JSON without hiding non-JSON error bodies.
+ *
+ * @param value - Provider response text.
+ */
+function parseJson(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Parses an optional numeric HTTP header.
+ *
+ * @param headers - Provider response headers.
+ * @param name - Case-insensitive header name.
+ */
+function parseNumberHeader(headers, name) {
+    const value = headers.get(name);
+    if (value === null)
+        return undefined;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}

package/dist/linear/schemas.d.ts

@@ -4392,10 +4392,10 @@ export declare const LINEAR_ISSUE_RELATION_SCHEMA: z.ZodObject<{
     updatedAt: z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodISODateTime, z.ZodTransform<Date, string>>]>;
 }, z.core.$strip>;
 export declare const LINEAR_PROVIDER_PROJECT_SCHEMA: z.ZodObject<{
-    createdAt: z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodISODateTime, z.ZodTransform<Date, string>>]>;
-    id: z.ZodString;
     name: z.ZodString;
     description: z.ZodString;
+    createdAt: z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodISODateTime, z.ZodTransform<Date, string>>]>;
+    id: z.ZodString;
     status: z.ZodObject<{
         color: z.ZodString;
         description: z.ZodNullable<z.ZodString>;
@@ -4471,6 +4471,7 @@ export declare const LINEAR_PROVIDER_PROJECT_SCHEMA: z.ZodObject<{
 }, z.core.$strip>;
 export declare const LINEAR_PROVIDER_ISSUE_SCHEMA: z.ZodObject<{
     number: z.ZodNumber;
+    description: z.ZodNullable<z.ZodString>;
     createdAt: z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodISODateTime, z.ZodTransform<Date, string>>]>;
     id: z.ZodString;
     project: z.ZodNullable<z.ZodObject<{
@@ -4479,7 +4480,6 @@ export declare const LINEAR_PROVIDER_ISSUE_SCHEMA: z.ZodObject<{
         slugId: z.ZodString;
         url: z.ZodString;
     }, z.core.$strip>>;
-    description: z.ZodNullable<z.ZodString>;
     completedAt: z.ZodNullable<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodISODateTime, z.ZodTransform<Date, string>>]>>;
     startedAt: z.ZodNullable<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodISODateTime, z.ZodTransform<Date, string>>]>>;
     team: z.ZodObject<{

package/dist/notion/schemas.d.ts

@@ -1419,8 +1419,8 @@ declare const RAW_NOTION_EVENT_SCHEMA: z.ZodDiscriminatedUnion<[z.ZodObject<{
             }>;
         }, z.core.$strip>;
         updated_fields: z.ZodArray<z.ZodEnum<{
-            filter: "filter";
             name: "name";
+            filter: "filter";
             sorts: "sorts";
             configuration: "configuration";
         }>>;
@@ -2877,8 +2877,8 @@ export declare const NOTION_EVENT_SCHEMA: z.ZodPipe<z.ZodDiscriminatedUnion<[z.Z
             }>;
         }, z.core.$strip>;
         updated_fields: z.ZodArray<z.ZodEnum<{
-            filter: "filter";
             name: "name";
+            filter: "filter";
             sorts: "sorts";
             configuration: "configuration";
         }>>;
@@ -3829,7 +3829,7 @@ export declare const NOTION_EVENT_SCHEMA: z.ZodPipe<z.ZodDiscriminatedUnion<[z.Z
             type: "team" | "page" | "space" | "agent" | "block" | "database";
             dataSourceId?: string | undefined;
         };
-        updatedFields: ("filter" | "name" | "sorts" | "configuration")[];
+        updatedFields: ("name" | "filter" | "sorts" | "configuration")[];
     };
     workspaceId: string;
     workspaceName: string;
@@ -4956,7 +4956,7 @@ export declare const NOTION_EVENT_SCHEMA: z.ZodPipe<z.ZodDiscriminatedUnion<[z.Z
             type: "team" | "page" | "space" | "agent" | "block" | "database";
             data_source_id?: string | undefined;
         };
-        updated_fields: ("filter" | "name" | "sorts" | "configuration")[];
+        updated_fields: ("name" | "filter" | "sorts" | "configuration")[];
     };
     entity: {
         id: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@automate.ax/integration-contracts",
-  "version": "0.107.0",
+  "version": "0.109.0",
   "description": "Shared integration payload contracts and provider primitives for Automate.ax.",
   "license": "MIT",
   "repository": {
@@ -50,7 +50,7 @@
     }
   },
   "dependencies": {
-    "@automate.ax/codec": "0.107.0",
+    "@automate.ax/codec": "0.109.0",
     "@cfworker/json-schema": "^4.1.1",
     "@googleapis/calendar": "^15.0.0",
     "@googleapis/forms": "^6.0.1",

package/src/airtable/api.ts

@@ -2,9 +2,10 @@ import * as z from "zod"
 
 export const AIRTABLE_API_ORIGIN = "https://api.airtable.com/v0/"
 
-const AIRTABLE_SECRET_SCHEMA = z.object({
-  accessToken: z.string().min(1),
-})
+const AIRTABLE_SECRET_SCHEMA = z.union([
+  z.object({ accessToken: z.string().min(1) }),
+  z.object({ apiKey: z.string().min(1) }),
+])
 const AIRTABLE_ERROR_SCHEMA = z.object({
   error: z.union([
     z.string(),
@@ -34,7 +35,9 @@ export interface AirtableApi {
  * @param secret - Refreshed Airtable integration secret.
  */
 export function getAirtableApi(secret: Record<string, unknown>): AirtableApi {
-  const { accessToken } = AIRTABLE_SECRET_SCHEMA.parse(secret)
+  const credential = AIRTABLE_SECRET_SCHEMA.parse(secret)
+  const accessToken =
+    "accessToken" in credential ? credential.accessToken : credential.apiKey
 
   return {
     request: async (path, init) => {

package/src/airtable/index.ts

@@ -1,10 +1,17 @@
 import * as z from "zod"
 import {
+  AIRTABLE_BASE_EVENT_SCHEMA,
+  AIRTABLE_FIELD_CREATED_EVENT_SCHEMA,
+  AIRTABLE_FIELD_DELETED_EVENT_SCHEMA,
+  AIRTABLE_FIELD_UPDATED_EVENT_SCHEMA,
   AIRTABLE_RECORD_CREATED_EVENT_SCHEMA,
   AIRTABLE_RECORD_DELETED_EVENT_SCHEMA,
   AIRTABLE_RECORD_MOVED_INTO_VIEW_EVENT_SCHEMA,
   AIRTABLE_RECORD_MOVED_OUT_OF_VIEW_EVENT_SCHEMA,
   AIRTABLE_RECORD_UPDATED_EVENT_SCHEMA,
+  AIRTABLE_TABLE_CREATED_EVENT_SCHEMA,
+  AIRTABLE_TABLE_DELETED_EVENT_SCHEMA,
+  AIRTABLE_TABLE_UPDATED_EVENT_SCHEMA,
 } from "./schemas"
 
 export * from "./api"
@@ -14,10 +21,26 @@ export * from "./schemas"
 export const AIRTABLE_TRIGGER_CONFIG_SCHEMA = z.object({
   baseId: z.string(),
   scopeId: z.string(),
-  scopeType: z.enum(["table", "view"]),
+  scopeType: z.enum(["base", "table", "view"]),
 })
 
 export const airtableTriggerContracts = {
+  "airtable.base.event": {
+    configSchema: AIRTABLE_TRIGGER_CONFIG_SCHEMA,
+    eventSchema: AIRTABLE_BASE_EVENT_SCHEMA,
+  },
+  "airtable.field.created": {
+    configSchema: AIRTABLE_TRIGGER_CONFIG_SCHEMA,
+    eventSchema: AIRTABLE_FIELD_CREATED_EVENT_SCHEMA,
+  },
+  "airtable.field.deleted": {
+    configSchema: AIRTABLE_TRIGGER_CONFIG_SCHEMA,
+    eventSchema: AIRTABLE_FIELD_DELETED_EVENT_SCHEMA,
+  },
+  "airtable.field.updated": {
+    configSchema: AIRTABLE_TRIGGER_CONFIG_SCHEMA,
+    eventSchema: AIRTABLE_FIELD_UPDATED_EVENT_SCHEMA,
+  },
   "airtable.record.created": {
     configSchema: AIRTABLE_TRIGGER_CONFIG_SCHEMA,
     eventSchema: AIRTABLE_RECORD_CREATED_EVENT_SCHEMA,
@@ -38,4 +61,16 @@ export const airtableTriggerContracts = {
     configSchema: AIRTABLE_TRIGGER_CONFIG_SCHEMA,
     eventSchema: AIRTABLE_RECORD_UPDATED_EVENT_SCHEMA,
   },
+  "airtable.table.created": {
+    configSchema: AIRTABLE_TRIGGER_CONFIG_SCHEMA,
+    eventSchema: AIRTABLE_TABLE_CREATED_EVENT_SCHEMA,
+  },
+  "airtable.table.deleted": {
+    configSchema: AIRTABLE_TRIGGER_CONFIG_SCHEMA,
+    eventSchema: AIRTABLE_TABLE_DELETED_EVENT_SCHEMA,
+  },
+  "airtable.table.updated": {
+    configSchema: AIRTABLE_TRIGGER_CONFIG_SCHEMA,
+    eventSchema: AIRTABLE_TABLE_UPDATED_EVENT_SCHEMA,
+  },
 } as const