@zapier/zapier-sdk 0.34.1 → 0.36.0

package/dist/plugins/tables/createTableFields/schemas.d.ts

@@ -0,0 +1,192 @@
+import { z } from "zod";
+import type { FunctionOptions } from "../../../types/functions";
+import type { ZapierAuthenticationError, ZapierApiError, ZapierValidationError, ZapierUnknownError } from "../../../types/errors";
+import { FieldTypeSchema, FieldItemSchema, type FieldItem } from "../listTableFields/schemas";
+export { FieldTypeSchema, FieldItemSchema };
+export type { FieldItem };
+export declare const CreateTableFieldsApiResponseSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        new: z.ZodObject<{
+            id: z.ZodNumber;
+            type: z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                link: "link";
+                email: "email";
+                uuid: "uuid";
+                text: "text";
+                datetime: "datetime";
+                decimal: "decimal";
+                json: "json";
+                multiple_string: "multiple_string";
+                labeled_string: "labeled_string";
+                multiple_labeled_string: "multiple_labeled_string";
+                multiple_text: "multiple_text";
+                multiple_boolean: "multiple_boolean";
+                multiple_number: "multiple_number";
+                multiple_decimal: "multiple_decimal";
+                multiple_datetime: "multiple_datetime";
+                multiple_uuid: "multiple_uuid";
+                multiple_json: "multiple_json";
+                formula: "formula";
+                button_trigger_zap: "button_trigger_zap";
+                button_continue_zap: "button_continue_zap";
+                multiple_email: "multiple_email";
+                multiple_link: "multiple_link";
+                currency: "currency";
+                phone_number: "phone_number";
+                ai_formula: "ai_formula";
+                linked_record: "linked_record";
+                multiple_linked_record: "multiple_linked_record";
+            }>;
+            name: z.ZodString;
+            created_at: z.ZodOptional<z.ZodString>;
+            edited_at: z.ZodOptional<z.ZodString>;
+            options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            is_order_field: z.ZodOptional<z.ZodBoolean>;
+            is_filter_field: z.ZodOptional<z.ZodBoolean>;
+            is_selected_field: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>;
+        old: z.ZodNullable<z.ZodObject<{
+            id: z.ZodNumber;
+            type: z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                link: "link";
+                email: "email";
+                uuid: "uuid";
+                text: "text";
+                datetime: "datetime";
+                decimal: "decimal";
+                json: "json";
+                multiple_string: "multiple_string";
+                labeled_string: "labeled_string";
+                multiple_labeled_string: "multiple_labeled_string";
+                multiple_text: "multiple_text";
+                multiple_boolean: "multiple_boolean";
+                multiple_number: "multiple_number";
+                multiple_decimal: "multiple_decimal";
+                multiple_datetime: "multiple_datetime";
+                multiple_uuid: "multiple_uuid";
+                multiple_json: "multiple_json";
+                formula: "formula";
+                button_trigger_zap: "button_trigger_zap";
+                button_continue_zap: "button_continue_zap";
+                multiple_email: "multiple_email";
+                multiple_link: "multiple_link";
+                currency: "currency";
+                phone_number: "phone_number";
+                ai_formula: "ai_formula";
+                linked_record: "linked_record";
+                multiple_linked_record: "multiple_linked_record";
+            }>;
+            name: z.ZodString;
+            created_at: z.ZodOptional<z.ZodString>;
+            edited_at: z.ZodOptional<z.ZodString>;
+            options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            is_order_field: z.ZodOptional<z.ZodBoolean>;
+            is_filter_field: z.ZodOptional<z.ZodBoolean>;
+            is_selected_field: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        kind: z.ZodEnum<{
+            created: "created";
+            updated: "updated";
+            deleted: "deleted";
+        }>;
+    }, z.core.$strip>>;
+    meta: z.ZodOptional<z.ZodObject<{
+        did_change: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CreateTableFieldsApiResponse = z.infer<typeof CreateTableFieldsApiResponseSchema>;
+export declare const NewFieldSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        link: "link";
+        email: "email";
+        uuid: "uuid";
+        text: "text";
+        datetime: "datetime";
+        decimal: "decimal";
+        json: "json";
+        multiple_string: "multiple_string";
+        labeled_string: "labeled_string";
+        multiple_labeled_string: "multiple_labeled_string";
+        multiple_text: "multiple_text";
+        multiple_boolean: "multiple_boolean";
+        multiple_number: "multiple_number";
+        multiple_decimal: "multiple_decimal";
+        multiple_datetime: "multiple_datetime";
+        multiple_uuid: "multiple_uuid";
+        multiple_json: "multiple_json";
+        formula: "formula";
+        button_trigger_zap: "button_trigger_zap";
+        button_continue_zap: "button_continue_zap";
+        multiple_email: "multiple_email";
+        multiple_link: "multiple_link";
+        currency: "currency";
+        phone_number: "phone_number";
+        ai_formula: "ai_formula";
+        linked_record: "linked_record";
+        multiple_linked_record: "multiple_linked_record";
+    }>;
+    name: z.ZodString;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type NewField = z.infer<typeof NewFieldSchema>;
+export declare const CreateTableFieldsOptionsSchema: z.ZodObject<{
+    tableId: z.ZodString;
+    fields: z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+            link: "link";
+            email: "email";
+            uuid: "uuid";
+            text: "text";
+            datetime: "datetime";
+            decimal: "decimal";
+            json: "json";
+            multiple_string: "multiple_string";
+            labeled_string: "labeled_string";
+            multiple_labeled_string: "multiple_labeled_string";
+            multiple_text: "multiple_text";
+            multiple_boolean: "multiple_boolean";
+            multiple_number: "multiple_number";
+            multiple_decimal: "multiple_decimal";
+            multiple_datetime: "multiple_datetime";
+            multiple_uuid: "multiple_uuid";
+            multiple_json: "multiple_json";
+            formula: "formula";
+            button_trigger_zap: "button_trigger_zap";
+            button_continue_zap: "button_continue_zap";
+            multiple_email: "multiple_email";
+            multiple_link: "multiple_link";
+            currency: "currency";
+            phone_number: "phone_number";
+            ai_formula: "ai_formula";
+            linked_record: "linked_record";
+            multiple_linked_record: "multiple_linked_record";
+        }>;
+        name: z.ZodString;
+        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CreateTableFieldsOptions = z.infer<typeof CreateTableFieldsOptionsSchema> & FunctionOptions;
+export interface CreateTableFieldsResult {
+    data: FieldItem[];
+}
+export type CreateTableFieldsError = ZapierAuthenticationError | ZapierApiError | ZapierValidationError | ZapierUnknownError;
+export interface CreateTableFieldsSdkFunction {
+    createTableFields: (options: CreateTableFieldsOptions) => Promise<CreateTableFieldsResult>;
+}
+//# sourceMappingURL=schemas.d.ts.map

package/dist/plugins/tables/createTableFields/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/createTableFields/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAChE,OAAO,KAAK,EACV,yBAAyB,EACzB,cAAc,EACd,qBAAqB,EACrB,kBAAkB,EACnB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,eAAe,EAEf,eAAe,EACf,KAAK,SAAS,EACf,MAAM,4BAA4B,CAAC;AAGpC,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,CAAC;AAC5C,YAAY,EAAE,SAAS,EAAE,CAAC;AAS1B,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAO7C,CAAC;AAEH,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAChD,OAAO,kCAAkC,CAC1C,CAAC;AAEF,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAWzB,CAAC;AAEH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAEtD,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAWQ,CAAC;AAEpD,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAC5C,OAAO,8BAA8B,CACtC,GACC,eAAe,CAAC;AAGlB,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,SAAS,EAAE,CAAC;CACnB;AAGD,MAAM,MAAM,sBAAsB,GAC9B,yBAAyB,GACzB,cAAc,GACd,qBAAqB,GACrB,kBAAkB,CAAC;AAGvB,MAAM,WAAW,4BAA4B;IAC3C,iBAAiB,EAAE,CACjB,OAAO,EAAE,wBAAwB,KAC9B,OAAO,CAAC,uBAAuB,CAAC,CAAC;CACvC"}

package/dist/plugins/tables/createTableFields/schemas.js

@@ -0,0 +1,42 @@
+import { z } from "zod";
+import { FieldTypeSchema, FieldApiItemSchema, FieldItemSchema, } from "../listTableFields/schemas";
+// Re-export for consumers
+export { FieldTypeSchema, FieldItemSchema };
+// The API returns a changeset format with new/old/kind for each field
+const FieldChangesetItemSchema = z.object({
+    new: FieldApiItemSchema,
+    old: FieldApiItemSchema.nullable(),
+    kind: z.enum(["created", "updated", "deleted"]),
+});
+export const CreateTableFieldsApiResponseSchema = z.object({
+    data: z.array(FieldChangesetItemSchema),
+    meta: z
+        .object({
+        did_change: z.boolean(),
+    })
+        .optional(),
+});
+export const NewFieldSchema = z.object({
+    type: FieldTypeSchema.describe("The data type of the field"),
+    name: z.string().min(1).describe("The display name of the field"),
+    options: z
+        .record(z.string(), z.unknown())
+        .optional()
+        .describe("Data configuration options for the field"),
+    config: z
+        .record(z.string(), z.unknown())
+        .optional()
+        .describe("Display configuration for the field"),
+});
+export const CreateTableFieldsOptionsSchema = z
+    .object({
+    tableId: z
+        .string()
+        .regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID")
+        .describe("The unique identifier of the table"),
+    fields: z
+        .array(NewFieldSchema)
+        .min(1)
+        .describe("Array of field definitions to create"),
+})
+    .describe("Create one or more fields in a table");

package/dist/plugins/tables/createTableRecords/index.d.ts

@@ -0,0 +1,18 @@
+import type { Plugin } from "../../../types/plugin";
+import type { ApiClient } from "../../../api";
+import { CreateTableRecordsOptionsSchema, type CreateTableRecordsOptions, type CreateTableRecordsResult } from "./schemas";
+import type { EventEmissionContext } from "../../eventEmission";
+export interface CreateTableRecordsPluginProvides {
+    createTableRecords: (options: CreateTableRecordsOptions) => Promise<CreateTableRecordsResult>;
+    context: {
+        meta: {
+            createTableRecords: {
+                inputSchema: typeof CreateTableRecordsOptionsSchema;
+            };
+        };
+    };
+}
+export declare const createTableRecordsPlugin: Plugin<{}, {
+    api: ApiClient;
+} & EventEmissionContext, CreateTableRecordsPluginProvides>;
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/tables/createTableRecords/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/createTableRecords/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,OAAO,EACL,+BAA+B,EAG/B,KAAK,yBAAyB,EAC9B,KAAK,wBAAwB,EAC9B,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAYhE,MAAM,WAAW,gCAAgC;IAC/C,kBAAkB,EAAE,CAClB,OAAO,EAAE,yBAAyB,KAC/B,OAAO,CAAC,wBAAwB,CAAC,CAAC;IACvC,OAAO,EAAE;QACP,IAAI,EAAE;YACJ,kBAAkB,EAAE;gBAClB,WAAW,EAAE,OAAO,+BAA+B,CAAC;aACrD,CAAC;SACH,CAAC;KACH,CAAC;CACH;AAED,eAAO,MAAM,wBAAwB,EAAE,MAAM,CAC3C,EAAE,EACF;IAAE,GAAG,EAAE,SAAS,CAAA;CAAE,GAAG,oBAAoB,EACzC,gCAAgC,CAsFjC,CAAC"}

package/dist/plugins/tables/createTableRecords/index.js

@@ -0,0 +1,67 @@
+import { createFunction } from "../../../utils/function-utils";
+import { CreateTableRecordsOptionsSchema, CreateTableRecordsApiResponseSchema, RecordItemSchema, } from "./schemas";
+import { createTelemetryCallback } from "../../../utils/telemetry-utils";
+import { ZapierAuthenticationError } from "../../../types/errors";
+import { tableIdResolver, tableRecordsResolver } from "../../../resolvers";
+import { tableRecordFormatter } from "../../../formatters";
+import { createFieldKeyTranslator, transformRecordItem, throwOnRecordErrors, throwOnResponseErrors, } from "../utils";
+export const createTableRecordsPlugin = ({ context }) => {
+    async function createTableRecords(options) {
+        const { api } = context;
+        const translator = await createFieldKeyTranslator({
+            api,
+            tableId: options.tableId,
+            keyMode: options.keyMode,
+        });
+        const rawResponse = await api.post(`/tables/api/v1/tables/${options.tableId}/records`, {
+            new_records: options.records.map((record) => ({
+                data: translator.translateInput(record.data),
+            })),
+        }, {
+            customErrorHandler: ({ status }) => {
+                if (status === 401) {
+                    return new ZapierAuthenticationError(`Authentication failed. Your token may not have permission to create records or may be expired. (HTTP ${status})`, { statusCode: status });
+                }
+                if (status === 403) {
+                    return new ZapierAuthenticationError(`Access forbidden. Your token may not have the required scopes to create records. (HTTP ${status})`, { statusCode: status });
+                }
+                if (status === 404) {
+                    return new Error(`Table not found: ${options.tableId}`);
+                }
+                return undefined;
+            },
+            authRequired: true,
+        });
+        throwOnResponseErrors(rawResponse);
+        const response = CreateTableRecordsApiResponseSchema.parse(rawResponse);
+        for (const changeset of response.data) {
+            throwOnRecordErrors(changeset.new);
+        }
+        return {
+            data: response.data.map((changeset) => ({
+                ...transformRecordItem(changeset.new),
+                data: translator.translateOutput(changeset.new.data),
+            })),
+        };
+    }
+    const createTableRecordsDefinition = createFunction(createTableRecords, CreateTableRecordsOptionsSchema, createTelemetryCallback(context.eventEmission.emitMethodCalled, createTableRecords.name));
+    return {
+        createTableRecords: createTableRecordsDefinition,
+        context: {
+            meta: {
+                createTableRecords: {
+                    categories: ["table"],
+                    type: "create",
+                    itemType: "Record",
+                    inputSchema: CreateTableRecordsOptionsSchema,
+                    outputSchema: RecordItemSchema,
+                    resolvers: {
+                        tableId: tableIdResolver,
+                        records: tableRecordsResolver,
+                    },
+                    formatter: tableRecordFormatter,
+                },
+            },
+        },
+    };
+};

package/dist/plugins/tables/createTableRecords/schemas.d.ts

@@ -0,0 +1,57 @@
+import { z } from "zod";
+import type { FunctionOptions } from "../../../types/functions";
+import type { ZapierAuthenticationError, ZapierApiError, ZapierValidationError, ZapierUnknownError } from "../../../types/errors";
+import { RecordItemSchema, type RecordItem } from "../getTableRecord/schemas";
+export { RecordItemSchema };
+export type { RecordItem };
+export declare const CreateTableRecordsApiResponseSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        change_id: z.ZodString;
+        old: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            created_at: z.ZodString;
+            edited_at: z.ZodString;
+            schema_revision_id: z.ZodNumber;
+            errors: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+            orig_data: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+            is_source_record: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        }, z.core.$strip>>;
+        new: z.ZodObject<{
+            id: z.ZodString;
+            data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            created_at: z.ZodString;
+            edited_at: z.ZodString;
+            schema_revision_id: z.ZodNumber;
+            errors: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+            orig_data: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+            is_source_record: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        }, z.core.$strip>;
+        changed_field_ids: z.ZodNullable<z.ZodArray<z.ZodNumber>>;
+        record_id: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CreateTableRecordsApiResponse = z.infer<typeof CreateTableRecordsApiResponseSchema>;
+export declare const NewRecordSchema: z.ZodObject<{
+    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+export type NewRecord = z.infer<typeof NewRecordSchema>;
+export declare const CreateTableRecordsOptionsSchema: z.ZodObject<{
+    tableId: z.ZodString;
+    records: z.ZodArray<z.ZodObject<{
+        data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>>;
+    keyMode: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        names: "names";
+        ids: "ids";
+    }>>>;
+}, z.core.$strip>;
+export type CreateTableRecordsOptions = z.infer<typeof CreateTableRecordsOptionsSchema> & FunctionOptions;
+export interface CreateTableRecordsResult {
+    data: RecordItem[];
+}
+export type CreateTableRecordsError = ZapierAuthenticationError | ZapierApiError | ZapierValidationError | ZapierUnknownError;
+export interface CreateTableRecordsSdkFunction {
+    createTableRecords: (options: CreateTableRecordsOptions) => Promise<CreateTableRecordsResult>;
+}
+//# sourceMappingURL=schemas.d.ts.map

package/dist/plugins/tables/createTableRecords/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/createTableRecords/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAChE,OAAO,KAAK,EACV,yBAAyB,EACzB,cAAc,EACd,qBAAqB,EACrB,kBAAkB,EACnB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAEL,gBAAgB,EAChB,KAAK,UAAU,EAChB,MAAM,2BAA2B,CAAC;AAInC,OAAO,EAAE,gBAAgB,EAAE,CAAC;AAC5B,YAAY,EAAE,UAAU,EAAE,CAAC;AAW3B,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;iBAE9C,CAAC;AAEH,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CACjD,OAAO,mCAAmC,CAC3C,CAAC;AAEF,eAAO,MAAM,eAAe;;iBAI1B,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD,eAAO,MAAM,+BAA+B;;;;;;;;;iBAaQ,CAAC;AAErD,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAC7C,OAAO,+BAA+B,CACvC,GACC,eAAe,CAAC;AAElB,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,UAAU,EAAE,CAAC;CACpB;AAED,MAAM,MAAM,uBAAuB,GAC/B,yBAAyB,GACzB,cAAc,GACd,qBAAqB,GACrB,kBAAkB,CAAC;AAEvB,MAAM,WAAW,6BAA6B;IAC5C,kBAAkB,EAAE,CAClB,OAAO,EAAE,yBAAyB,KAC/B,OAAO,CAAC,wBAAwB,CAAC,CAAC;CACxC"}

package/dist/plugins/tables/createTableRecords/schemas.js

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import { RecordApiItemSchema, RecordItemSchema, } from "../getTableRecord/schemas";
+import { KeyModeSchema } from "../utils";
+// Re-export for consumers
+export { RecordItemSchema };
+// The API returns changesets with old/new values
+const RecordChangesetSchema = z.object({
+    change_id: z.string(),
+    old: RecordApiItemSchema.nullable(),
+    new: RecordApiItemSchema,
+    changed_field_ids: z.array(z.number()).nullable(),
+    record_id: z.string(),
+});
+export const CreateTableRecordsApiResponseSchema = z.object({
+    data: z.array(RecordChangesetSchema),
+});
+export const NewRecordSchema = z.object({
+    data: z
+        .record(z.string(), z.unknown())
+        .describe("The field values for the record, keyed by field ID"),
+});
+export const CreateTableRecordsOptionsSchema = z
+    .object({
+    tableId: z
+        .string()
+        .regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID")
+        .describe("The unique identifier of the table"),
+    records: z
+        .array(NewRecordSchema)
+        .min(1)
+        .max(100)
+        .describe("Array of records to create (max 100)"),
+    keyMode: KeyModeSchema,
+})
+    .describe("Create one or more records in a table");

package/dist/plugins/tables/deleteTable/index.d.ts

@@ -0,0 +1,18 @@
+import type { Plugin } from "../../../types/plugin";
+import type { ApiClient } from "../../../api";
+import { DeleteTableOptionsSchema, type DeleteTableOptions, type DeleteTableResult } from "./schemas";
+import type { EventEmissionContext } from "../../eventEmission";
+export interface DeleteTablePluginProvides {
+    deleteTable: (options: DeleteTableOptions) => Promise<DeleteTableResult>;
+    context: {
+        meta: {
+            deleteTable: {
+                inputSchema: typeof DeleteTableOptionsSchema;
+            };
+        };
+    };
+}
+export declare const deleteTablePlugin: Plugin<{}, {
+    api: ApiClient;
+} & EventEmissionContext, DeleteTablePluginProvides>;
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/tables/deleteTable/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/deleteTable/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,OAAO,EACL,wBAAwB,EACxB,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACvB,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAKhE,MAAM,WAAW,yBAAyB;IACxC,WAAW,EAAE,CAAC,OAAO,EAAE,kBAAkB,KAAK,OAAO,CAAC,iBAAiB,CAAC,CAAC;IACzE,OAAO,EAAE;QACP,IAAI,EAAE;YACJ,WAAW,EAAE;gBACX,WAAW,EAAE,OAAO,wBAAwB,CAAC;aAC9C,CAAC;SACH,CAAC;KACH,CAAC;CACH;AAED,eAAO,MAAM,iBAAiB,EAAE,MAAM,CACpC,EAAE,EACF;IAAE,GAAG,EAAE,SAAS,CAAA;CAAE,GAAG,oBAAoB,EACzC,yBAAyB,CAyD1B,CAAC"}

package/dist/plugins/tables/deleteTable/index.js

@@ -0,0 +1,43 @@
+import { createFunction } from "../../../utils/function-utils";
+import { DeleteTableOptionsSchema, } from "./schemas";
+import { createTelemetryCallback } from "../../../utils/telemetry-utils";
+import { ZapierAuthenticationError } from "../../../types/errors";
+import { tableIdResolver } from "../../../resolvers";
+export const deleteTablePlugin = ({ context }) => {
+    async function deleteTable(options) {
+        const { api } = context;
+        await api.delete(`/tables/api/v1/tables/${options.tableId}`, undefined, {
+            customErrorHandler: ({ status }) => {
+                if (status === 401) {
+                    return new ZapierAuthenticationError(`Authentication failed. Your token may not have permission to delete tables or may be expired. (HTTP ${status})`, { statusCode: status });
+                }
+                if (status === 403) {
+                    return new ZapierAuthenticationError(`Access forbidden. Your token may not have the required scopes to delete tables. (HTTP ${status})`, { statusCode: status });
+                }
+                return undefined;
+            },
+            authRequired: true,
+        });
+        return {
+            success: true,
+        };
+    }
+    const deleteTableDefinition = createFunction(deleteTable, DeleteTableOptionsSchema, createTelemetryCallback(context.eventEmission.emitMethodCalled, deleteTable.name));
+    return {
+        deleteTable: deleteTableDefinition,
+        context: {
+            meta: {
+                deleteTable: {
+                    categories: ["table"],
+                    type: "delete",
+                    itemType: "Table",
+                    inputSchema: DeleteTableOptionsSchema,
+                    resolvers: {
+                        tableId: tableIdResolver,
+                    },
+                    confirm: "delete",
+                },
+            },
+        },
+    };
+};

package/dist/plugins/tables/deleteTable/schemas.d.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+import type { FunctionOptions } from "../../../types/functions";
+import type { ZapierAuthenticationError, ZapierApiError, ZapierValidationError, ZapierNotFoundError, ZapierUnknownError } from "../../../types/errors";
+export declare const DeleteTableOptionsSchema: z.ZodObject<{
+    tableId: z.ZodString;
+}, z.core.$strip>;
+export type DeleteTableOptions = z.infer<typeof DeleteTableOptionsSchema> & FunctionOptions;
+export interface DeleteTableResult {
+    success: boolean;
+}
+export type DeleteTableError = ZapierAuthenticationError | ZapierApiError | ZapierValidationError | ZapierNotFoundError | ZapierUnknownError;
+export interface DeleteTableSdkFunction {
+    deleteTable: (options: DeleteTableOptions) => Promise<DeleteTableResult>;
+}
+//# sourceMappingURL=schemas.d.ts.map

package/dist/plugins/tables/deleteTable/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/deleteTable/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAChE,OAAO,KAAK,EACV,yBAAyB,EACzB,cAAc,EACd,qBAAqB,EACrB,mBAAmB,EACnB,kBAAkB,EACnB,MAAM,uBAAuB,CAAC;AAE/B,eAAO,MAAM,wBAAwB;;iBAOE,CAAC;AAExC,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,GACvE,eAAe,CAAC;AAGlB,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,OAAO,CAAC;CAClB;AAGD,MAAM,MAAM,gBAAgB,GACxB,yBAAyB,GACzB,cAAc,GACd,qBAAqB,GACrB,mBAAmB,GACnB,kBAAkB,CAAC;AAGvB,MAAM,WAAW,sBAAsB;IACrC,WAAW,EAAE,CAAC,OAAO,EAAE,kBAAkB,KAAK,OAAO,CAAC,iBAAiB,CAAC,CAAC;CAC1E"}

package/dist/plugins/tables/deleteTable/schemas.js

@@ -0,0 +1,9 @@
+import { z } from "zod";
+export const DeleteTableOptionsSchema = z
+    .object({
+    tableId: z
+        .string()
+        .regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID")
+        .describe("The unique identifier of the table to delete"),
+})
+    .describe("Delete a table by its ID");

package/dist/plugins/tables/deleteTableFields/index.d.ts

@@ -0,0 +1,18 @@
+import type { Plugin } from "../../../types/plugin";
+import type { ApiClient } from "../../../api";
+import { DeleteTableFieldsOptionsSchema, type DeleteTableFieldsOptions, type DeleteTableFieldsResult } from "./schemas";
+import type { EventEmissionContext } from "../../eventEmission";
+export interface DeleteTableFieldsPluginProvides {
+    deleteTableFields: (options: DeleteTableFieldsOptions) => Promise<DeleteTableFieldsResult>;
+    context: {
+        meta: {
+            deleteTableFields: {
+                inputSchema: typeof DeleteTableFieldsOptionsSchema;
+            };
+        };
+    };
+}
+export declare const deleteTableFieldsPlugin: Plugin<{}, {
+    api: ApiClient;
+} & EventEmissionContext, DeleteTableFieldsPluginProvides>;
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/tables/deleteTableFields/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/deleteTableFields/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,OAAO,EACL,8BAA8B,EAC9B,KAAK,wBAAwB,EAC7B,KAAK,uBAAuB,EAC7B,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAMhE,MAAM,WAAW,+BAA+B;IAC9C,iBAAiB,EAAE,CACjB,OAAO,EAAE,wBAAwB,KAC9B,OAAO,CAAC,uBAAuB,CAAC,CAAC;IACtC,OAAO,EAAE;QACP,IAAI,EAAE;YACJ,iBAAiB,EAAE;gBACjB,WAAW,EAAE,OAAO,8BAA8B,CAAC;aACpD,CAAC;SACH,CAAC;KACH,CAAC;CACH;AAED,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAC1C,EAAE,EACF;IAAE,GAAG,EAAE,SAAS,CAAA;CAAE,GAAG,oBAAoB,EACzC,+BAA+B,CAoEhC,CAAC"}

package/dist/plugins/tables/deleteTableFields/index.js

@@ -0,0 +1,50 @@
+import { createFunction } from "../../../utils/function-utils";
+import { DeleteTableFieldsOptionsSchema, } from "./schemas";
+import { createTelemetryCallback } from "../../../utils/telemetry-utils";
+import { ZapierAuthenticationError } from "../../../types/errors";
+import { tableIdResolver, tableFieldIdsResolver } from "../../../resolvers";
+import { resolveFieldKeys } from "../utils";
+export const deleteTableFieldsPlugin = ({ context }) => {
+    async function deleteTableFields(options) {
+        const { api } = context;
+        const numericFieldIds = await resolveFieldKeys({
+            api,
+            tableId: options.tableId,
+            fieldKeys: options.fieldKeys,
+        });
+        await api.delete(`/tables/api/v1/tables/${options.tableId}/fields`, { field_ids: numericFieldIds }, {
+            customErrorHandler: ({ status }) => {
+                if (status === 401) {
+                    return new ZapierAuthenticationError(`Authentication failed. Your token may not have permission to delete fields or may be expired. (HTTP ${status})`, { statusCode: status });
+                }
+                if (status === 403) {
+                    return new ZapierAuthenticationError(`Access forbidden. Your token may not have the required scopes to delete fields. (HTTP ${status})`, { statusCode: status });
+                }
+                return undefined;
+            },
+            authRequired: true,
+        });
+        return {
+            success: true,
+        };
+    }
+    const deleteTableFieldsDefinition = createFunction(deleteTableFields, DeleteTableFieldsOptionsSchema, createTelemetryCallback(context.eventEmission.emitMethodCalled, deleteTableFields.name));
+    return {
+        deleteTableFields: deleteTableFieldsDefinition,
+        context: {
+            meta: {
+                deleteTableFields: {
+                    categories: ["table"],
+                    type: "delete",
+                    itemType: "Field",
+                    inputSchema: DeleteTableFieldsOptionsSchema,
+                    resolvers: {
+                        tableId: tableIdResolver,
+                        fieldKeys: tableFieldIdsResolver,
+                    },
+                    confirm: "delete",
+                },
+            },
+        },
+    };
+};

package/dist/plugins/tables/deleteTableFields/schemas.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+import type { FunctionOptions } from "../../../types/functions";
+import type { ZapierAuthenticationError, ZapierApiError, ZapierValidationError, ZapierNotFoundError, ZapierUnknownError } from "../../../types/errors";
+export declare const DeleteTableFieldsOptionsSchema: z.ZodObject<{
+    tableId: z.ZodString;
+    fieldKeys: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+}, z.core.$strip>;
+export type DeleteTableFieldsOptions = z.infer<typeof DeleteTableFieldsOptionsSchema> & FunctionOptions;
+export interface DeleteTableFieldsResult {
+    success: boolean;
+}
+export type DeleteTableFieldsError = ZapierAuthenticationError | ZapierApiError | ZapierValidationError | ZapierNotFoundError | ZapierUnknownError;
+export interface DeleteTableFieldsSdkFunction {
+    deleteTableFields: (options: DeleteTableFieldsOptions) => Promise<DeleteTableFieldsResult>;
+}
+//# sourceMappingURL=schemas.d.ts.map

package/dist/plugins/tables/deleteTableFields/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/deleteTableFields/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAChE,OAAO,KAAK,EACV,yBAAyB,EACzB,cAAc,EACd,qBAAqB,EACrB,mBAAmB,EACnB,kBAAkB,EACnB,MAAM,uBAAuB,CAAC;AAE/B,eAAO,MAAM,8BAA8B;;;iBAaU,CAAC;AAEtD,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAC5C,OAAO,8BAA8B,CACtC,GACC,eAAe,CAAC;AAGlB,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,OAAO,CAAC;CAClB;AAGD,MAAM,MAAM,sBAAsB,GAC9B,yBAAyB,GACzB,cAAc,GACd,qBAAqB,GACrB,mBAAmB,GACnB,kBAAkB,CAAC;AAGvB,MAAM,WAAW,4BAA4B;IAC3C,iBAAiB,EAAE,CACjB,OAAO,EAAE,wBAAwB,KAC9B,OAAO,CAAC,uBAAuB,CAAC,CAAC;CACvC"}

package/dist/plugins/tables/deleteTableFields/schemas.js

@@ -0,0 +1,13 @@
+import { z } from "zod";
+export const DeleteTableFieldsOptionsSchema = z
+    .object({
+    tableId: z
+        .string()
+        .regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID")
+        .describe("The unique identifier of the table"),
+    fieldKeys: z
+        .array(z.union([z.string(), z.number()]))
+        .min(1)
+        .describe('Fields to delete. Accepts field names (e.g., "Email") or IDs (e.g., "f6", "6", or 6).'),
+})
+    .describe("Delete one or more fields from a table");