@zapier/zapier-sdk 0.34.1 → 0.36.0

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

@@ -0,0 +1,85 @@
+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";
+import { DEFAULT_PAGE_SIZE } from "../../../constants";
+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 = {};
+        if (options.pageSize !== undefined) {
+            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, DEFAULT_PAGE_SIZE);
+    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");

package/dist/plugins/tables/utils.d.ts

@@ -0,0 +1,63 @@
+import { z } from "zod";
+import type { ApiClient } from "../../api";
+import type { TableApiItem, TableItem } from "./listTables/schemas";
+import type { RecordApiItem, RecordItem } from "./getTableRecord/schemas";
+import type { FieldApiItem, FieldItem } from "./listTableFields/schemas";
+export declare function formatFieldValue(v: unknown): string;
+/**
+ * Convert a field ID to its numeric form for the Tables API.
+ * Accepts "f6", "6", or 6 and returns 6.
+ */
+export declare function toNumericFieldId(id: string | number): number;
+export declare function transformTableItem(apiItem: TableApiItem): TableItem;
+export declare function transformFieldItem(apiItem: FieldApiItem): FieldItem;
+export declare function transformRecordItem(apiItem: RecordApiItem): RecordItem;
+/**
+ * Check a record API item for field-level validation errors and throw if any
+ * are present. The errors dict is keyed by field ID, and each value has
+ * `{s, v, e, h}` where `h` is the human-friendly message and `e` is the
+ * technical one.
+ */
+export declare function throwOnRecordErrors(record: RecordApiItem): void;
+/**
+ * Check an API response for top-level validation errors (in `meta.errors`)
+ * and throw if any are present.
+ */
+export declare function throwOnResponseErrors(response: {
+    meta?: {
+        errors?: unknown[];
+    } | null;
+}): void;
+export declare const KeyModeSchema: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+    names: "names";
+    ids: "ids";
+}>>>;
+export type KeyMode = z.infer<typeof KeyModeSchema>;
+export declare function isFieldId(key: string): boolean;
+export declare const NESTED_COMPONENTS: Record<string, Set<string>>;
+/**
+ * Resolve an array of field keys (names like "Email" or IDs like "f6", "6", 6)
+ * to numeric field IDs for the API. Only fetches field metadata if any
+ * non-ID keys are present.
+ */
+export declare function resolveFieldKeys({ api, tableId, fieldKeys, }: {
+    api: ApiClient;
+    tableId: string;
+    fieldKeys: Array<string | number>;
+}): Promise<number[]>;
+export interface FieldKeyTranslator {
+    translateInput(data: Record<string, unknown>): Record<string, unknown>;
+    translateOutput(data: Record<string, unknown>): Record<string, unknown>;
+    translateFieldKey(key: string): string;
+}
+/**
+ * Resolve the field mapping for a table and return a translator.
+ * Fetches field metadata from the API once (when keyMode is "names"),
+ * then all translate methods are synchronous.
+ */
+export declare function createFieldKeyTranslator({ api, tableId, keyMode, }: {
+    api: ApiClient;
+    tableId: string;
+    keyMode: KeyMode;
+}): Promise<FieldKeyTranslator>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/plugins/tables/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/plugins/tables/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAE3C,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACpE,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAC1E,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAEzE,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAUnD;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAS5D;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,YAAY,GAAG,SAAS,CAYnE;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,YAAY,GAAG,SAAS,CAUnE;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,aAAa,GAAG,UAAU,CAOtE;AAkCD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI,CAgB/D;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE;IAC9C,IAAI,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,OAAO,EAAE,CAAA;KAAE,GAAG,IAAI,CAAC;CACtC,GAAG,IAAI,CASP;AAED,eAAO,MAAM,aAAa;;;IAMvB,CAAC;AAEJ,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAIpD,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAE9C;AAED,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAKzD,CAAC;AA6CF;;;;GAIG;AACH,wBAAsB,gBAAgB,CAAC,EACrC,GAAG,EACH,OAAO,EACP,SAAS,GACV,EAAE;IACD,GAAG,EAAE,SAAS,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC;CACnC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAyBpB;AAED,MAAM,WAAW,kBAAkB;IACjC,cAAc,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACvE,eAAe,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACxE,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;CACxC;AAED;;;;GAIG;AACH,wBAAsB,wBAAwB,CAAC,EAC7C,GAAG,EACH,OAAO,EACP,OAAO,GACR,EAAE;IACD,GAAG,EAAE,SAAS,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;CAClB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAkF9B"}