@zapier/zapier-sdk 0.34.0 → 0.35.0

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

@@ -0,0 +1,120 @@
+import { z } from "zod";
+import type { PaginatedSdkFunction } 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 ListTableRecordsApiResponseSchema: z.ZodObject<{
+    data: z.ZodArray<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>>;
+    meta: z.ZodOptional<z.ZodObject<{
+        pagination: z.ZodOptional<z.ZodObject<{
+            start_cursor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            end_cursor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            has_more: z.ZodOptional<z.ZodBoolean>;
+            has_less: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ListTableRecordsApiResponse = z.infer<typeof ListTableRecordsApiResponseSchema>;
+declare const FilterOperatorSchema: z.ZodEnum<{
+    in: "in";
+    search: "search";
+    contains: "contains";
+    gt: "gt";
+    gte: "gte";
+    lt: "lt";
+    lte: "lte";
+    exact: "exact";
+    different: "different";
+    icontains: "icontains";
+    range: "range";
+    isnull: "isnull";
+    startswith: "startswith";
+    is_within: "is_within";
+}>;
+export type FilterOperator = z.infer<typeof FilterOperatorSchema>;
+declare const FilterConditionSchema: z.ZodObject<{
+    fieldKey: z.ZodString;
+    operator: z.ZodEnum<{
+        in: "in";
+        search: "search";
+        contains: "contains";
+        gt: "gt";
+        gte: "gte";
+        lt: "lt";
+        lte: "lte";
+        exact: "exact";
+        different: "different";
+        icontains: "icontains";
+        range: "range";
+        isnull: "isnull";
+        startswith: "startswith";
+        is_within: "is_within";
+    }>;
+    value: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+export type FilterCondition = z.infer<typeof FilterConditionSchema>;
+export declare const SortConditionSchema: z.ZodObject<{
+    fieldKey: z.ZodString;
+    direction: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>>>;
+}, z.core.$strip>;
+export type SortCondition = z.infer<typeof SortConditionSchema>;
+export declare const ListTableRecordsOptionsSchema: z.ZodObject<{
+    tableId: z.ZodString;
+    filters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        fieldKey: z.ZodString;
+        operator: z.ZodEnum<{
+            in: "in";
+            search: "search";
+            contains: "contains";
+            gt: "gt";
+            gte: "gte";
+            lt: "lt";
+            lte: "lte";
+            exact: "exact";
+            different: "different";
+            icontains: "icontains";
+            range: "range";
+            isnull: "isnull";
+            startswith: "startswith";
+            is_within: "is_within";
+        }>;
+        value: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>>>;
+    sort: z.ZodOptional<z.ZodObject<{
+        fieldKey: z.ZodString;
+        direction: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>>>;
+    }, z.core.$strip>>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    maxItems: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+    keyMode: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        names: "names";
+        ids: "ids";
+    }>>>;
+}, z.core.$strip>;
+export type ListTableRecordsOptions = z.infer<typeof ListTableRecordsOptionsSchema>;
+export interface ListTableRecordsPage {
+    data: RecordItem[];
+    nextCursor?: string;
+}
+export type ListTableRecordsError = ZapierAuthenticationError | ZapierApiError | ZapierValidationError | ZapierUnknownError;
+export interface ListTableRecordsSdkFunction {
+    listTableRecords: PaginatedSdkFunction<ListTableRecordsOptions, RecordItem>;
+}
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/listTableRecords/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AACrE,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;AAE3B,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;iBAc5C,CAAC;AAEH,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAC/C,OAAO,iCAAiC,CACzC,CAAC;AAEF,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;EAexB,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;iBAIzB,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAIpE,eAAO,MAAM,mBAAmB;;;;;;iBAK9B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyBgC,CAAC;AAE3E,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,6BAA6B,CACrC,CAAC;AAEF,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,UAAU,EAAE,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,MAAM,qBAAqB,GAC7B,yBAAyB,GACzB,cAAc,GACd,qBAAqB,GACrB,kBAAkB,CAAC;AAEvB,MAAM,WAAW,2BAA2B;IAC1C,gBAAgB,EAAE,oBAAoB,CAAC,uBAAuB,EAAE,UAAU,CAAC,CAAC;CAC7E"}

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

@@ -0,0 +1,74 @@
+import { z } from "zod";
+import { RecordApiItemSchema, RecordItemSchema, } from "../getTableRecord/schemas";
+import { KeyModeSchema } from "../utils";
+// Re-export for consumers
+export { RecordItemSchema };
+export const ListTableRecordsApiResponseSchema = z.object({
+    data: z.array(RecordApiItemSchema),
+    meta: z
+        .object({
+        pagination: z
+            .object({
+            start_cursor: z.string().nullable().optional(),
+            end_cursor: z.string().nullable().optional(),
+            has_more: z.boolean().optional(),
+            has_less: z.boolean().optional(),
+        })
+            .optional(),
+    })
+        .optional(),
+});
+const FilterOperatorSchema = z.enum([
+    "exact",
+    "different",
+    "contains",
+    "icontains",
+    "gte",
+    "gt",
+    "lt",
+    "lte",
+    "range",
+    "in",
+    "isnull",
+    "startswith",
+    "search",
+    "is_within",
+]);
+const FilterConditionSchema = z.object({
+    fieldKey: z.string().describe("The field key to filter on (e.g. f1, f2)"),
+    operator: FilterOperatorSchema.describe("The comparison operator"),
+    value: z.unknown().optional().describe("The value to compare against"),
+});
+const SortDirectionSchema = z.enum(["asc", "desc"]);
+export const SortConditionSchema = z.object({
+    fieldKey: z.string().describe("The field key to sort by"),
+    direction: SortDirectionSchema.optional()
+        .default("asc")
+        .describe("Sort direction"),
+});
+export const ListTableRecordsOptionsSchema = z
+    .object({
+    tableId: z
+        .string()
+        .regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID")
+        .describe("The unique identifier of the table"),
+    filters: z
+        .array(FilterConditionSchema)
+        .optional()
+        .describe("Filter conditions for the query"),
+    sort: SortConditionSchema.optional().describe("Sort records by a field"),
+    pageSize: z
+        .number()
+        .min(1)
+        .max(1000)
+        .optional()
+        .describe("Number of records per page (max 1000)"),
+    maxItems: z
+        .number()
+        .min(1)
+        .optional()
+        .describe("Maximum total items to return across all pages"),
+    cursor: z.string().optional().describe("Cursor to start from"),
+    keyMode: KeyModeSchema,
+})
+    .describe("List records in a table with optional filtering and sorting");

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

@@ -0,0 +1,24 @@
+import type { GetContextType, Plugin } from "../../../types/plugin";
+import { ListTablesOptionsSchema, type ListTablesOptions, type TableItem } from "./schemas";
+import type { ApiPluginProvides } from "../../api";
+import type { EventEmissionContext } from "../../eventEmission";
+export interface ListTablesPluginProvides {
+    listTables: (options?: ListTablesOptions) => Promise<{
+        data: TableItem[];
+        nextCursor?: string;
+    }> & AsyncIterable<{
+        data: TableItem[];
+        nextCursor?: string;
+    }> & {
+        items(): AsyncIterable<TableItem>;
+    };
+    context: {
+        meta: {
+            listTables: {
+                inputSchema: typeof ListTablesOptionsSchema;
+            };
+        };
+    };
+}
+export declare const listTablesPlugin: Plugin<{}, GetContextType<ApiPluginProvides> & EventEmissionContext, ListTablesPluginProvides>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/listTables/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAEpE,OAAO,EAEL,uBAAuB,EAEvB,KAAK,iBAAiB,EACtB,KAAK,SAAS,EACf,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AACnD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAqBhE,MAAM,WAAW,wBAAwB;IACvC,UAAU,EAAE,CAAC,OAAO,CAAC,EAAE,iBAAiB,KAAK,OAAO,CAAC;QACnD,IAAI,EAAE,SAAS,EAAE,CAAC;QAClB,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,CAAC,GACA,aAAa,CAAC;QAAE,IAAI,EAAE,SAAS,EAAE,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,GAAG;QAC1D,KAAK,IAAI,aAAa,CAAC,SAAS,CAAC,CAAC;KACnC,CAAC;IACJ,OAAO,EAAE;QACP,IAAI,EAAE;YACJ,UAAU,EAAE;gBACV,WAAW,EAAE,OAAO,uBAAuB,CAAC;aAC7C,CAAC;SACH,CAAC;KACH,CAAC;CACH;AAED,eAAO,MAAM,gBAAgB,EAAE,MAAM,CACnC,EAAE,EACF,cAAc,CAAC,iBAAiB,CAAC,GAAG,oBAAoB,EACxD,wBAAwB,CAoFzB,CAAC"}

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

@@ -0,0 +1,83 @@
+import { createPaginatedFunction } from "../../../utils/function-utils";
+import { ListTablesApiResponseSchema, ListTablesOptionsSchema, TableItemSchema, } from "./schemas";
+import { createTelemetryCallback } from "../../../utils/telemetry-utils";
+import { stripPageSuffix } from "../../../utils/string-utils";
+import { ZapierAuthenticationError } from "../../../types/errors";
+import { transformTableItem } from "../utils";
+function extractNextCursor(links) {
+    if (!links?.next) {
+        return undefined;
+    }
+    try {
+        const url = new URL(links.next);
+        const offset = url.searchParams.get("offset");
+        return offset || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export const listTablesPlugin = ({ context }) => {
+    async function listTablesPage(options) {
+        const { api } = context;
+        const searchParams = {
+            limit: options.pageSize.toString(),
+        };
+        if (options?.tableIds && options.tableIds.length > 0) {
+            searchParams.ids = options.tableIds.join(",");
+        }
+        if (options?.kind) {
+            searchParams.kind = options.kind;
+        }
+        if (options?.search) {
+            searchParams.q = options.search;
+        }
+        if (options?.owner) {
+            let ownerId = options.owner;
+            if (ownerId === "me") {
+                const profile = await api.get("/zapier/api/v4/profile/", {
+                    authRequired: true,
+                });
+                ownerId = String(profile.id);
+            }
+            searchParams.owner_customuser_id = ownerId;
+        }
+        if (options.cursor) {
+            searchParams.offset = options.cursor;
+        }
+        const rawResponse = await api.get("/tables/api/v1/tables", {
+            searchParams,
+            customErrorHandler: ({ status }) => {
+                if (status === 401) {
+                    return new ZapierAuthenticationError(`Authentication failed. Your token may not have permission to list 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 list tables. (HTTP ${status})`, { statusCode: status });
+                }
+                return undefined;
+            },
+            authRequired: true,
+        });
+        const response = ListTablesApiResponseSchema.parse(rawResponse);
+        return {
+            data: response.data.map(transformTableItem),
+            nextCursor: extractNextCursor(response.links),
+        };
+    }
+    const methodName = stripPageSuffix(listTablesPage.name);
+    const listTablesDefinition = createPaginatedFunction(listTablesPage, ListTablesOptionsSchema, createTelemetryCallback(context.eventEmission.emitMethodCalled, methodName), methodName);
+    return {
+        listTables: listTablesDefinition,
+        context: {
+            meta: {
+                listTables: {
+                    categories: ["table"],
+                    type: "list",
+                    itemType: "Table",
+                    inputSchema: ListTablesOptionsSchema,
+                    outputSchema: TableItemSchema,
+                },
+            },
+        },
+    };
+};

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

@@ -0,0 +1,78 @@
+import { z } from "zod";
+import type { PaginatedSdkFunction } from "../../../types/functions";
+import type { ZapierAuthenticationError, ZapierApiError, ZapierValidationError, ZapierUnknownError } from "../../../types/errors";
+export declare const TableApiItemSchema: 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>;
+export type TableApiItem = z.infer<typeof TableApiItemSchema>;
+export declare const ListTablesApiResponseSchema: z.ZodObject<{
+    data: z.ZodArray<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>>;
+    links: z.ZodOptional<z.ZodObject<{
+        next: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ListTablesApiResponse = z.infer<typeof ListTablesApiResponseSchema>;
+export declare const TableItemSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    created_at: z.ZodString;
+    edited_at: z.ZodString;
+    kind: z.ZodEnum<{
+        table: "table";
+        virtual_table: "virtual_table";
+    }>;
+    owner_account_id: z.ZodString;
+    profile_id: z.ZodString;
+    parent_table_id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type TableItem = z.infer<typeof TableItemSchema>;
+export declare const ListTablesOptionsSchema: z.ZodObject<{
+    tableIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    kind: z.ZodOptional<z.ZodEnum<{
+        table: "table";
+        virtual_table: "virtual_table";
+        both: "both";
+    }>>;
+    search: z.ZodOptional<z.ZodString>;
+    owner: z.ZodOptional<z.ZodString>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    maxItems: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ListTablesOptions = z.infer<typeof ListTablesOptionsSchema>;
+export interface ListTablesPage {
+    data: TableItem[];
+    nextCursor?: string;
+}
+export type ListTablesError = ZapierAuthenticationError | ZapierApiError | ZapierValidationError | ZapierUnknownError;
+export interface ListTablesSdkFunction {
+    listTables: PaginatedSdkFunction<ListTablesOptions, TableItem>;
+}
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/listTables/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AACrE,OAAO,KAAK,EACV,yBAAyB,EACzB,cAAc,EACd,qBAAqB,EACrB,kBAAkB,EACnB,MAAM,uBAAuB,CAAC;AAE/B,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;iBAW7B,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;iBAOtC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,eAAO,MAAM,eAAe;;;;;;;;;;;;;iBAU1B,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD,eAAO,MAAM,uBAAuB;;;;;;;;;;;;iBAgC0B,CAAC;AAE/D,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAGxE,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,SAAS,EAAE,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAGD,MAAM,MAAM,eAAe,GACvB,yBAAyB,GACzB,cAAc,GACd,qBAAqB,GACrB,kBAAkB,CAAC;AAGvB,MAAM,WAAW,qBAAqB;IACpC,UAAU,EAAE,oBAAoB,CAAC,iBAAiB,EAAE,SAAS,CAAC,CAAC;CAChE"}

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

@@ -0,0 +1,63 @@
+import { z } from "zod";
+export const TableApiItemSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    description: z.string().nullable().optional(),
+    created_at: z.string(),
+    edited_at: z.string(),
+    kind: z.enum(["table", "virtual_table"]),
+    owner_account_id: z.number(),
+    owner_user_id: z.number().nullable().optional(),
+    owner_zapier_customuser_id: z.number(),
+    parent_table_id: z.string().nullable().optional(),
+});
+export const ListTablesApiResponseSchema = z.object({
+    data: z.array(TableApiItemSchema),
+    links: z
+        .object({
+        next: z.string().nullable().optional(),
+    })
+        .optional(),
+});
+export const TableItemSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    description: z.string().optional(),
+    created_at: z.string(),
+    edited_at: z.string(),
+    kind: z.enum(["table", "virtual_table"]),
+    owner_account_id: z.string(),
+    profile_id: z.string(),
+    parent_table_id: z.string().optional(),
+});
+export const ListTablesOptionsSchema = z
+    .object({
+    tableIds: z
+        .array(z.string())
+        .optional()
+        .describe("Filter by specific table IDs"),
+    kind: z
+        .enum(["table", "virtual_table", "both"])
+        .optional()
+        .describe("Filter by table type"),
+    search: z
+        .string()
+        .optional()
+        .describe("Search term to filter tables by name"),
+    owner: z
+        .string()
+        .optional()
+        .describe('Filter by table owner. Use "me" for the current user, or a numeric user ID.'),
+    pageSize: z
+        .number()
+        .min(1)
+        .optional()
+        .describe("Number of tables per page"),
+    maxItems: z
+        .number()
+        .min(1)
+        .optional()
+        .describe("Maximum total items to return across all pages"),
+    cursor: z.string().optional().describe("Cursor to start from"),
+})
+    .describe("List tables available to the authenticated user");

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

@@ -0,0 +1,18 @@
+import type { Plugin } from "../../../types/plugin";
+import type { ApiClient } from "../../../api";
+import { UpdateTableRecordsOptionsSchema, type UpdateTableRecordsOptions, type UpdateTableRecordsResult } from "./schemas";
+import type { EventEmissionContext } from "../../eventEmission";
+export interface UpdateTableRecordsPluginProvides {
+    updateTableRecords: (options: UpdateTableRecordsOptions) => Promise<UpdateTableRecordsResult>;
+    context: {
+        meta: {
+            updateTableRecords: {
+                inputSchema: typeof UpdateTableRecordsOptionsSchema;
+            };
+        };
+    };
+}
+export declare const updateTableRecordsPlugin: Plugin<{}, {
+    api: ApiClient;
+} & EventEmissionContext, UpdateTableRecordsPluginProvides>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/updateTableRecords/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;AAehE,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,CAuFjC,CAAC"}

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

@@ -0,0 +1,68 @@
+import { createFunction } from "../../../utils/function-utils";
+import { UpdateTableRecordsOptionsSchema, UpdateTableRecordsApiResponseSchema, RecordItemSchema, } from "./schemas";
+import { createTelemetryCallback } from "../../../utils/telemetry-utils";
+import { ZapierAuthenticationError } from "../../../types/errors";
+import { tableIdResolver, tableUpdateRecordsResolver, } from "../../../resolvers";
+import { tableRecordFormatter } from "../../../formatters";
+import { createFieldKeyTranslator, transformRecordItem, throwOnRecordErrors, throwOnResponseErrors, } from "../utils";
+export const updateTableRecordsPlugin = ({ context }) => {
+    async function updateTableRecords(options) {
+        const { api } = context;
+        const translator = await createFieldKeyTranslator({
+            api,
+            tableId: options.tableId,
+            keyMode: options.keyMode,
+        });
+        const rawResponse = await api.patch(`/tables/api/v1/tables/${options.tableId}/records`, {
+            updated_records: options.records.map((record) => ({
+                id: record.id,
+                data: translator.translateInput(record.data),
+            })),
+        }, {
+            customErrorHandler: ({ status }) => {
+                if (status === 401) {
+                    return new ZapierAuthenticationError(`Authentication failed. Your token may not have permission to update 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 update records. (HTTP ${status})`, { statusCode: status });
+                }
+                if (status === 404) {
+                    return new Error(`Table not found: ${options.tableId}`);
+                }
+                return undefined;
+            },
+            authRequired: true,
+        });
+        throwOnResponseErrors(rawResponse);
+        const response = UpdateTableRecordsApiResponseSchema.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 updateTableRecordsDefinition = createFunction(updateTableRecords, UpdateTableRecordsOptionsSchema, createTelemetryCallback(context.eventEmission.emitMethodCalled, updateTableRecords.name));
+    return {
+        updateTableRecords: updateTableRecordsDefinition,
+        context: {
+            meta: {
+                updateTableRecords: {
+                    categories: ["table"],
+                    type: "update",
+                    itemType: "Record",
+                    inputSchema: UpdateTableRecordsOptionsSchema,
+                    outputSchema: RecordItemSchema,
+                    resolvers: {
+                        tableId: tableIdResolver,
+                        records: tableUpdateRecordsResolver,
+                    },
+                    formatter: tableRecordFormatter,
+                },
+            },
+        },
+    };
+};

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

@@ -0,0 +1,59 @@
+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 UpdateTableRecordsApiResponseSchema: 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 UpdateTableRecordsApiResponse = z.infer<typeof UpdateTableRecordsApiResponseSchema>;
+export declare const UpdateRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+export type UpdateRecord = z.infer<typeof UpdateRecordSchema>;
+export declare const UpdateTableRecordsOptionsSchema: z.ZodObject<{
+    tableId: z.ZodString;
+    records: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        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 UpdateTableRecordsOptions = z.infer<typeof UpdateTableRecordsOptionsSchema> & FunctionOptions;
+export interface UpdateTableRecordsResult {
+    data: RecordItem[];
+}
+export type UpdateTableRecordsError = ZapierAuthenticationError | ZapierApiError | ZapierValidationError | ZapierUnknownError;
+export interface UpdateTableRecordsSdkFunction {
+    updateTableRecords: (options: UpdateTableRecordsOptions) => Promise<UpdateTableRecordsResult>;
+}
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/updateTableRecords/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;AAU3B,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;iBAE9C,CAAC;AAEH,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CACjD,OAAO,mCAAmC,CAC3C,CAAC;AAEF,eAAO,MAAM,kBAAkB;;;iBAK7B,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,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/updateTableRecords/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 };
+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 UpdateTableRecordsApiResponseSchema = z.object({
+    data: z.array(RecordChangesetSchema),
+});
+export const UpdateRecordSchema = z.object({
+    id: z.string().describe("The record ID to update"),
+    data: z
+        .record(z.string(), z.unknown())
+        .describe("The field values to update, keyed by field key"),
+});
+export const UpdateTableRecordsOptionsSchema = 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(UpdateRecordSchema)
+        .min(1)
+        .max(100)
+        .describe("Array of records to update (max 100)"),
+    keyMode: KeyModeSchema,
+})
+    .describe("Update one or more records in a table");