@zapier/zapier-sdk 0.34.0 → 0.35.0

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");

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

@@ -0,0 +1,18 @@
+import type { Plugin } from "../../../types/plugin";
+import type { ApiClient } from "../../../api";
+import { DeleteTableRecordsOptionsSchema, type DeleteTableRecordsOptions, type DeleteTableRecordsResult } from "./schemas";
+import type { EventEmissionContext } from "../../eventEmission";
+export interface DeleteTableRecordsPluginProvides {
+    deleteTableRecords: (options: DeleteTableRecordsOptions) => Promise<DeleteTableRecordsResult>;
+    context: {
+        meta: {
+            deleteTableRecords: {
+                inputSchema: typeof DeleteTableRecordsOptionsSchema;
+            };
+        };
+    };
+}
+export declare const deleteTableRecordsPlugin: Plugin<{}, {
+    api: ApiClient;
+} & EventEmissionContext, DeleteTableRecordsPluginProvides>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/deleteTableRecords/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,EAC/B,KAAK,yBAAyB,EAC9B,KAAK,wBAAwB,EAC9B,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAKhE,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,CA8DjC,CAAC"}

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

@@ -0,0 +1,44 @@
+import { createFunction } from "../../../utils/function-utils";
+import { DeleteTableRecordsOptionsSchema, } from "./schemas";
+import { createTelemetryCallback } from "../../../utils/telemetry-utils";
+import { ZapierAuthenticationError } from "../../../types/errors";
+import { tableIdResolver, tableRecordIdsResolver } from "../../../resolvers";
+export const deleteTableRecordsPlugin = ({ context }) => {
+    async function deleteTableRecords(options) {
+        const { api } = context;
+        await api.delete(`/tables/api/v1/tables/${options.tableId}/records`, { record_ids: options.recordIds }, {
+            customErrorHandler: ({ status }) => {
+                if (status === 401) {
+                    return new ZapierAuthenticationError(`Authentication failed. Your token may not have permission to delete 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 delete records. (HTTP ${status})`, { statusCode: status });
+                }
+                return undefined;
+            },
+            authRequired: true,
+        });
+        return {
+            success: true,
+        };
+    }
+    const deleteTableRecordsDefinition = createFunction(deleteTableRecords, DeleteTableRecordsOptionsSchema, createTelemetryCallback(context.eventEmission.emitMethodCalled, deleteTableRecords.name));
+    return {
+        deleteTableRecords: deleteTableRecordsDefinition,
+        context: {
+            meta: {
+                deleteTableRecords: {
+                    categories: ["table"],
+                    type: "delete",
+                    itemType: "Record",
+                    inputSchema: DeleteTableRecordsOptionsSchema,
+                    resolvers: {
+                        tableId: tableIdResolver,
+                        recordIds: tableRecordIdsResolver,
+                    },
+                    confirm: "delete",
+                },
+            },
+        },
+    };
+};

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

@@ -0,0 +1,16 @@
+import { z } from "zod";
+import type { FunctionOptions } from "../../../types/functions";
+import type { ZapierAuthenticationError, ZapierApiError, ZapierValidationError, ZapierUnknownError } from "../../../types/errors";
+export declare const DeleteTableRecordsOptionsSchema: z.ZodObject<{
+    tableId: z.ZodString;
+    recordIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type DeleteTableRecordsOptions = z.infer<typeof DeleteTableRecordsOptionsSchema> & FunctionOptions;
+export interface DeleteTableRecordsResult {
+    success: boolean;
+}
+export type DeleteTableRecordsError = ZapierAuthenticationError | ZapierApiError | ZapierValidationError | ZapierUnknownError;
+export interface DeleteTableRecordsSdkFunction {
+    deleteTableRecords: (options: DeleteTableRecordsOptions) => Promise<DeleteTableRecordsResult>;
+}
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/deleteTableRecords/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;AAE/B,eAAO,MAAM,+BAA+B;;;iBAcU,CAAC;AAEvD,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAC7C,OAAO,+BAA+B,CACvC,GACC,eAAe,CAAC;AAElB,MAAM,WAAW,wBAAwB;IACvC,OAAO,EAAE,OAAO,CAAC;CAClB;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/deleteTableRecords/schemas.js

@@ -0,0 +1,14 @@
+import { z } from "zod";
+export const DeleteTableRecordsOptionsSchema = z
+    .object({
+    tableId: z
+        .string()
+        .regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID")
+        .describe("The unique identifier of the table"),
+    recordIds: z
+        .array(z.string().regex(/^[A-Z0-9]{26}$/, "Record ID must be a valid ULID"))
+        .min(1)
+        .max(100)
+        .describe("Array of record IDs to delete (max 100)"),
+})
+    .describe("Delete one or more records from a table");

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

@@ -0,0 +1,20 @@
+import type { Plugin } from "../../../types/plugin";
+import type { ApiClient } from "../../../api";
+import { GetTableOptionsSchema, type GetTableOptions, type TableItem } from "./schemas";
+import type { EventEmissionContext } from "../../eventEmission";
+export interface GetTablePluginProvides {
+    getTable: (options: GetTableOptions) => Promise<{
+        data: TableItem;
+    }>;
+    context: {
+        meta: {
+            getTable: {
+                inputSchema: typeof GetTableOptionsSchema;
+            };
+        };
+    };
+}
+export declare const getTablePlugin: Plugin<{}, {
+    api: ApiClient;
+} & EventEmissionContext, GetTablePluginProvides>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/getTable/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,OAAO,EAEL,qBAAqB,EAErB,KAAK,eAAe,EACpB,KAAK,SAAS,EACf,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAMhE,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,CAAC,OAAO,EAAE,eAAe,KAAK,OAAO,CAAC;QAAE,IAAI,EAAE,SAAS,CAAA;KAAE,CAAC,CAAC;IACrE,OAAO,EAAE;QACP,IAAI,EAAE;YACJ,QAAQ,EAAE;gBACR,WAAW,EAAE,OAAO,qBAAqB,CAAC;aAC3C,CAAC;SACH,CAAC;KACH,CAAC;CACH;AAED,eAAO,MAAM,cAAc,EAAE,MAAM,CACjC,EAAE,EACF;IAAE,GAAG,EAAE,SAAS,CAAA;CAAE,GAAG,oBAAoB,EACzC,sBAAsB,CAgEvB,CAAC"}

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

@@ -0,0 +1,48 @@
+import { createFunction } from "../../../utils/function-utils";
+import { GetTableApiResponseSchema, GetTableOptionsSchema, TableItemSchema, } from "./schemas";
+import { createTelemetryCallback } from "../../../utils/telemetry-utils";
+import { ZapierAuthenticationError } from "../../../types/errors";
+import { tableIdResolver } from "../../../resolvers";
+import { transformTableItem } from "../utils";
+export const getTablePlugin = ({ context }) => {
+    async function getTable(options) {
+        const { api } = context;
+        const rawResponse = await api.get(`/tables/api/v1/tables/${options.tableId}`, {
+            customErrorHandler: ({ status }) => {
+                if (status === 401) {
+                    return new ZapierAuthenticationError(`Authentication failed. Your token may not have permission to access this table 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 access this table. (HTTP ${status})`, { statusCode: status });
+                }
+                if (status === 404) {
+                    return new Error(`Table not found: ${options.tableId}`);
+                }
+                return undefined;
+            },
+            authRequired: true,
+        });
+        const response = GetTableApiResponseSchema.parse(rawResponse);
+        return {
+            data: transformTableItem(response.data),
+        };
+    }
+    const getTableDefinition = createFunction(getTable, GetTableOptionsSchema, createTelemetryCallback(context.eventEmission.emitMethodCalled, getTable.name));
+    return {
+        getTable: getTableDefinition,
+        context: {
+            meta: {
+                getTable: {
+                    categories: ["table"],
+                    type: "item",
+                    itemType: "Table",
+                    inputSchema: GetTableOptionsSchema,
+                    outputSchema: TableItemSchema,
+                    resolvers: {
+                        tableId: tableIdResolver,
+                    },
+                },
+            },
+        },
+    };
+};

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

@@ -0,0 +1,34 @@
+import { z } from "zod";
+import type { ZapierAuthenticationError, ZapierApiError, ZapierValidationError, ZapierUnknownError } from "../../../types/errors";
+import { TableItemSchema, TableApiItemSchema, type TableItem, type TableApiItem } from "../listTables/schemas";
+export { TableItemSchema, TableApiItemSchema };
+export type { TableItem, TableApiItem };
+export declare const GetTableApiResponseSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        created_at: z.ZodString;
+        edited_at: z.ZodString;
+        kind: z.ZodEnum<{
+            table: "table";
+            virtual_table: "virtual_table";
+        }>;
+        owner_account_id: z.ZodNumber;
+        owner_user_id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        owner_zapier_customuser_id: z.ZodNumber;
+        parent_table_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type GetTableApiResponse = z.infer<typeof GetTableApiResponseSchema>;
+export declare const GetTableOptionsSchema: z.ZodObject<{
+    tableId: z.ZodString;
+}, z.core.$strip>;
+export type GetTableOptions = z.infer<typeof GetTableOptionsSchema>;
+export type GetTableError = ZapierAuthenticationError | ZapierApiError | ZapierValidationError | ZapierUnknownError;
+export interface GetTableSdkFunction {
+    getTable: (options: GetTableOptions) => Promise<{
+        data: TableItem;
+    }>;
+}
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/getTable/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EACV,yBAAyB,EACzB,cAAc,EACd,qBAAqB,EACrB,kBAAkB,EACnB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,eAAe,EACf,kBAAkB,EAClB,KAAK,SAAS,EACd,KAAK,YAAY,EAClB,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EAAE,eAAe,EAAE,kBAAkB,EAAE,CAAC;AAC/C,YAAY,EAAE,SAAS,EAAE,YAAY,EAAE,CAAC;AAExC,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;iBAEpC,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,eAAO,MAAM,qBAAqB;;iBAO4B,CAAC;AAE/D,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAGpE,MAAM,MAAM,aAAa,GACrB,yBAAyB,GACzB,cAAc,GACd,qBAAqB,GACrB,kBAAkB,CAAC;AAGvB,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,CAAC,OAAO,EAAE,eAAe,KAAK,OAAO,CAAC;QAAE,IAAI,EAAE,SAAS,CAAA;KAAE,CAAC,CAAC;CACtE"}

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

@@ -0,0 +1,15 @@
+import { z } from "zod";
+import { TableItemSchema, TableApiItemSchema, } from "../listTables/schemas";
+// Re-export for consumers
+export { TableItemSchema, TableApiItemSchema };
+export const GetTableApiResponseSchema = z.object({
+    data: TableApiItemSchema,
+});
+export const GetTableOptionsSchema = 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 retrieve"),
+})
+    .describe("Get detailed information about a specific table");

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

@@ -0,0 +1,18 @@
+import type { Plugin } from "../../../types/plugin";
+import type { ApiClient } from "../../../api";
+import { GetTableRecordOptionsSchema, type GetTableRecordOptions, type GetTableRecordResult } from "./schemas";
+import type { EventEmissionContext } from "../../eventEmission";
+export interface GetTableRecordPluginProvides {
+    getTableRecord: (options: GetTableRecordOptions) => Promise<GetTableRecordResult>;
+    context: {
+        meta: {
+            getTableRecord: {
+                inputSchema: typeof GetTableRecordOptionsSchema;
+            };
+        };
+    };
+}
+export declare const getTableRecordPlugin: Plugin<{}, {
+    api: ApiClient;
+} & EventEmissionContext, GetTableRecordPluginProvides>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/getTableRecord/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,2BAA2B,EAG3B,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EAC1B,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAQhE,MAAM,WAAW,4BAA4B;IAC3C,cAAc,EAAE,CACd,OAAO,EAAE,qBAAqB,KAC3B,OAAO,CAAC,oBAAoB,CAAC,CAAC;IACnC,OAAO,EAAE;QACP,IAAI,EAAE;YACJ,cAAc,EAAE;gBACd,WAAW,EAAE,OAAO,2BAA2B,CAAC;aACjD,CAAC;SACH,CAAC;KACH,CAAC;CACH;AAED,eAAO,MAAM,oBAAoB,EAAE,MAAM,CACvC,EAAE,EACF;IAAE,GAAG,EAAE,SAAS,CAAA;CAAE,GAAG,oBAAoB,EACzC,4BAA4B,CA4E7B,CAAC"}

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

@@ -0,0 +1,60 @@
+import { createFunction } from "../../../utils/function-utils";
+import { GetTableRecordOptionsSchema, GetTableRecordApiResponseSchema, RecordItemSchema, } from "./schemas";
+import { createTelemetryCallback } from "../../../utils/telemetry-utils";
+import { ZapierAuthenticationError } from "../../../types/errors";
+import { tableIdResolver, tableRecordIdResolver } from "../../../resolvers";
+import { tableRecordFormatter } from "../../../formatters";
+import { createFieldKeyTranslator } from "../utils";
+import { transformRecordItem } from "../utils";
+export const getTableRecordPlugin = ({ context }) => {
+    async function getTableRecord(options) {
+        const { api } = context;
+        const rawResponse = await api.get(`/tables/api/v1/tables/${options.tableId}/records/${options.recordId}`, {
+            customErrorHandler: ({ status }) => {
+                if (status === 401) {
+                    return new ZapierAuthenticationError(`Authentication failed. Your token may not have permission to access this record 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 access this record. (HTTP ${status})`, { statusCode: status });
+                }
+                if (status === 404) {
+                    return new Error(`Record not found: ${options.recordId}`);
+                }
+                return undefined;
+            },
+            authRequired: true,
+        });
+        const response = GetTableRecordApiResponseSchema.parse(rawResponse);
+        const translator = await createFieldKeyTranslator({
+            api,
+            tableId: options.tableId,
+            keyMode: options.keyMode,
+        });
+        return {
+            data: {
+                ...transformRecordItem(response.data),
+                data: translator.translateOutput(response.data.data),
+            },
+        };
+    }
+    const getTableRecordDefinition = createFunction(getTableRecord, GetTableRecordOptionsSchema, createTelemetryCallback(context.eventEmission.emitMethodCalled, getTableRecord.name));
+    return {
+        getTableRecord: getTableRecordDefinition,
+        context: {
+            meta: {
+                getTableRecord: {
+                    categories: ["table"],
+                    type: "item",
+                    itemType: "Record",
+                    inputSchema: GetTableRecordOptionsSchema,
+                    outputSchema: RecordItemSchema,
+                    resolvers: {
+                        tableId: tableIdResolver,
+                        recordId: tableRecordIdResolver,
+                    },
+                    formatter: tableRecordFormatter,
+                },
+            },
+        },
+    };
+};