@zapier/zapier-sdk 0.77.0 → 0.77.2

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

@@ -1,116 +0,0 @@
-export declare const updateTableRecordsPlugin: (sdk: {
-    context: {
-        api: import("../../..").ApiClient;
-        resolveCredentials: () => Promise<string | {
-            clientId: string;
-            clientSecret: string;
-            type?: "client_credentials" | undefined;
-            baseUrl?: string | undefined;
-            scope?: string | undefined;
-        } | {
-            clientId: string;
-            type?: "pkce" | undefined;
-            baseUrl?: string | undefined;
-            scope?: string | undefined;
-        } | undefined>;
-    };
-} & {
-    context: import("../../eventEmission").EventEmissionContext;
-} & {
-    listTables: (options?: ({
-        tables?: string[] | undefined;
-        tableIds?: string[] | undefined;
-        kind?: "table" | "virtual_table" | "both" | undefined;
-        search?: string | undefined;
-        owner?: string | undefined;
-        includeShared?: boolean | undefined;
-        pageSize?: number | undefined;
-        maxItems?: number | undefined;
-        cursor?: string | undefined;
-    } & {
-        cursor?: string;
-        pageSize?: number;
-        maxItems?: number;
-    }) | undefined) => import("kitcore").PaginatedSdkResult<{
-        id: string;
-        name: string;
-        created_at: string;
-        edited_at: string;
-        kind: "table" | "virtual_table";
-        account_id: string;
-        profile_id: string;
-        description?: string | undefined;
-        parent_table_id?: string | undefined;
-    }>;
-} & {
-    context: {
-        meta: {
-            listTables: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-} & {
-    listTableFields: (options?: {
-        table: string;
-        fields?: (string | number)[] | undefined;
-        fieldKeys?: (string | number)[] | undefined;
-        trash?: "only" | "include" | "exclude" | undefined;
-    } | {
-        tableId: string;
-        fields?: (string | number)[] | undefined;
-        fieldKeys?: (string | number)[] | undefined;
-        trash?: "only" | "include" | "exclude" | undefined;
-    } | undefined) => Promise<{
-        data: {
-            id: string;
-            type: "string" | "number" | "boolean" | "text" | "datetime" | "decimal" | "json" | "email" | "link" | "multiple_string" | "labeled_string" | "multiple_labeled_string" | "multiple_text" | "multiple_boolean" | "multiple_number" | "multiple_decimal" | "multiple_datetime" | "uuid" | "multiple_uuid" | "multiple_json" | "formula" | "button_trigger_zap" | "button_continue_zap" | "multiple_email" | "multiple_link" | "currency" | "phone_number" | "ai_formula" | "linked_record" | "multiple_linked_record";
-            name: string;
-            created_at?: string | undefined;
-            edited_at?: string | undefined;
-            options?: Record<string, unknown> | undefined;
-            config?: Record<string, unknown> | undefined;
-            deleted_at?: string | null | undefined;
-        }[];
-    }>;
-} & {
-    context: {
-        meta: {
-            listTableFields: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-} & {
-    context: {
-        meta: Record<string, import("kitcore").PluginMeta>;
-    };
-}) => {
-    updateTableRecords: (options?: {
-        table: string;
-        records: {
-            id: string;
-            data: Record<string, unknown>;
-        }[];
-        keyMode: "names" | "ids";
-    } | {
-        tableId: string;
-        records: {
-            id: string;
-            data: Record<string, unknown>;
-        }[];
-        keyMode: "names" | "ids";
-    } | undefined) => Promise<{
-        data: {
-            data: Record<string, unknown>;
-            id: string;
-            created_at: string;
-            edited_at: string;
-            deleted_at?: string | null | undefined;
-        }[];
-    }>;
-} & {
-    context: {
-        meta: {
-            updateTableRecords: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-};
-export type UpdateTableRecordsPluginProvides = ReturnType<typeof updateTableRecordsPlugin>;
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/updateTableRecords/index.ts"],"names":[],"mappings":"AAwBA,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuDpC,CAAC;AAEF,MAAM,MAAM,gCAAgC,GAAG,UAAU,CACvD,OAAO,wBAAwB,CAChC,CAAC"}

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

@@ -1,47 +0,0 @@
-import { definePlugin } from "kitcore";
-import { createPluginMethod } from "kitcore";
-import { UpdateTableRecordsOptionsInputSchema, UpdateTableRecordsApiResponseSchema, RecordItemSchema, } from "./schemas";
-import { tableIdResolver, tableUpdateRecordsResolver, } from "../../../resolvers";
-import { tableRecordFormatter } from "../../../formatters";
-import { createFieldKeyTranslator, transformRecordItem, throwOnRecordErrors, throwOnResponseErrors, } from "../utils";
-import { tablesDefaults } from "../shared";
-export const updateTableRecordsPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
-    ...tablesDefaults,
-    name: "updateTableRecords",
-    type: "update",
-    itemType: "Record",
-    returnType: "RecordItem[]",
-    inputSchema: UpdateTableRecordsOptionsInputSchema,
-    outputSchema: RecordItemSchema,
-    resolvers: {
-        table: tableIdResolver,
-        records: tableUpdateRecordsResolver,
-    },
-    formatter: tableRecordFormatter,
-    handler: async ({ sdk, options }) => {
-        const { api } = sdk.context;
-        const tableId = "table" in options ? options.table : options.tableId;
-        const translator = await createFieldKeyTranslator({
-            api,
-            tableId,
-            keyMode: options.keyMode,
-        });
-        const rawResponse = await api.patch(`/tables/api/v1/tables/${tableId}/records`, {
-            updated_records: options.records.map((record) => ({
-                id: record.id,
-                data: translator.translateInput(record.data),
-            })),
-        }, { authRequired: true, resource: { type: "table", id: tableId } });
-        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),
-            })),
-        };
-    },
-}));

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

@@ -1,97 +0,0 @@
-import { z } from "zod";
-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>>;
-            deleted_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        }, 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>>;
-            deleted_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        }, 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<{
-    table: z.ZodString & {
-        _def: z.core.$ZodStringDef & import("kitcore").PositionalMetadata;
-    };
-    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>;
-declare const UpdateTableRecordsOptionsSchemaDeprecated: 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 declare const UpdateTableRecordsOptionsInputSchema: z.ZodUnion<readonly [z.ZodObject<{
-    table: z.ZodString & {
-        _def: z.core.$ZodStringDef & import("kitcore").PositionalMetadata;
-    };
-    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>, 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> | (Omit<z.infer<typeof UpdateTableRecordsOptionsSchemaDeprecated>, "tableId"> & {
-    /** @deprecated Use `table` instead. */
-    tableId: z.infer<typeof UpdateTableRecordsOptionsSchemaDeprecated>["tableId"];
-});
-export interface UpdateTableRecordsResult {
-    data: RecordItem[];
-}
-export interface UpdateTableRecordsSdkFunction {
-    updateTableRecords: (options: UpdateTableRecordsOptions) => Promise<UpdateTableRecordsResult>;
-}
-//# sourceMappingURL=schemas.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/updateTableRecords/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,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;AAc9D,eAAO,MAAM,+BAA+B;;;;;;;;;;;;iBAMF,CAAC;AAG3C,QAAA,MAAM,yCAAyC;;;;;;;;;;iBAOf,CAAC;AAGjC,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;mBAKP,CAAC;AAG3C,MAAM,MAAM,yBAAyB,GACjC,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,GAC/C,CAAC,IAAI,CACH,CAAC,CAAC,KAAK,CAAC,OAAO,yCAAyC,CAAC,EACzD,SAAS,CACV,GAAG;IACF,uCAAuC;IACvC,OAAO,EAAE,CAAC,CAAC,KAAK,CACd,OAAO,yCAAyC,CACjD,CAAC,SAAS,CAAC,CAAC;CACd,CAAC,CAAC;AAEP,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,UAAU,EAAE,CAAC;CACpB;AAED,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

@@ -1,55 +0,0 @@
-import { z } from "zod";
-import { TablePropertySchema } from "../../../types/properties";
-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"),
-});
-const UpdateTableRecordsDescription = "Update one or more records in a table";
-const UpdateTableRecordsBase = z.object({
-    records: z
-        .array(UpdateRecordSchema)
-        .min(1)
-        .max(100)
-        .describe("Array of records to update (max 100)"),
-    keyMode: KeyModeSchema,
-});
-// Schema for docs/registry (new param names only)
-export const UpdateTableRecordsOptionsSchema = z
-    .object({
-    table: TablePropertySchema,
-})
-    .merge(UpdateTableRecordsBase)
-    .describe(UpdateTableRecordsDescription)
-    .meta({ aliases: { tableId: "table" } });
-// Deprecated schema (backward compat)
-const UpdateTableRecordsOptionsSchemaDeprecated = z
-    .object({
-    tableId: z
-        .string()
-        .regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID")
-        .describe("The unique identifier of the table"),
-})
-    .merge(UpdateTableRecordsBase);
-// Union for runtime validation
-export const UpdateTableRecordsOptionsInputSchema = z
-    .union([
-    UpdateTableRecordsOptionsSchema,
-    UpdateTableRecordsOptionsSchemaDeprecated,
-])
-    .describe(UpdateTableRecordsDescription);

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

@@ -1,69 +0,0 @@
-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 const TrashSchema: z.ZodOptional<z.ZodEnum<{
-    only: "only";
-    include: "include";
-    exclude: "exclude";
-}>>;
-export type Trash = z.infer<typeof TrashSchema>;
-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

@@ -1 +0,0 @@
-{"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,CAiBnE;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,YAAY,GAAG,SAAS,CAWnE;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,aAAa,GAAG,UAAU,CAQtE;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;AAEpD,eAAO,MAAM,WAAW;;;;GAKrB,CAAC;AAEJ,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAIhD,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAE9C;AAED,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAKzD,CAAC;AA8CF;;;;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"}

package/dist/plugins/tables/utils.js

@@ -1,270 +0,0 @@
-import { z } from "zod";
-import { ZapierValidationError } from "../../types/errors";
-export function formatFieldValue(v) {
-    if (v == null)
-        return "";
-    if (typeof v === "object") {
-        try {
-            return JSON.stringify(v);
-        }
-        catch {
-            return String(v);
-        }
-    }
-    return String(v);
-}
-/**
- * Convert a field ID to its numeric form for the Tables API.
- * Accepts "f6", "6", or 6 and returns 6.
- */
-export function toNumericFieldId(id) {
-    if (typeof id === "number")
-        return id;
-    const num = parseInt(id.replace(/^f/, ""), 10);
-    if (isNaN(num)) {
-        throw new ZapierValidationError(`Invalid field ID: "${id}". Expected a numeric ID like "f6", "6", or 6.`);
-    }
-    return num;
-}
-export function transformTableItem(apiItem) {
-    return {
-        id: apiItem.id,
-        name: apiItem.name,
-        description: apiItem.description ?? undefined,
-        created_at: apiItem.created_at,
-        edited_at: apiItem.edited_at,
-        kind: apiItem.kind,
-        account_id: String(apiItem.owner_account_public_id ?? apiItem.owner_account_id),
-        profile_id: String(apiItem.owner_zapier_customuser_public_id ??
-            apiItem.owner_zapier_customuser_id),
-        parent_table_id: apiItem.parent_table_id ?? undefined,
-    };
-}
-export function transformFieldItem(apiItem) {
-    return {
-        id: `f${apiItem.id}`,
-        type: apiItem.type,
-        name: apiItem.name,
-        created_at: apiItem.created_at,
-        edited_at: apiItem.edited_at,
-        options: apiItem.options,
-        config: apiItem.config,
-        deleted_at: apiItem.deleted_at,
-    };
-}
-export function transformRecordItem(apiItem) {
-    return {
-        id: apiItem.id,
-        data: apiItem.data,
-        created_at: apiItem.created_at,
-        edited_at: apiItem.edited_at,
-        deleted_at: apiItem.deleted_at,
-    };
-}
-function formatRecordError(fieldId, err) {
-    const message = err.h || err.e || "validation error";
-    if (err.v !== undefined) {
-        return `Field ${fieldId}: ${message} (value: ${JSON.stringify(err.v)})`;
-    }
-    return `Field ${fieldId}: ${message}`;
-}
-function formatResponseError(err) {
-    const message = err.human_title || err.title || "Unknown error";
-    if (err.meta && Object.keys(err.meta).length > 0) {
-        const metaParts = Object.entries(err.meta)
-            .map(([key, val]) => `${key}: ${JSON.stringify(val)}`)
-            .join(", ");
-        return `${message} (${metaParts})`;
-    }
-    return message;
-}
-/**
- * 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 function throwOnRecordErrors(record) {
-    if (!record.errors)
-        return;
-    const messages = [];
-    for (const [fieldId, error] of Object.entries(record.errors)) {
-        const err = error;
-        if (err.s === "error") {
-            messages.push(formatRecordError(fieldId, err));
-        }
-    }
-    if (messages.length > 0) {
-        throw new ZapierValidationError(`Record ${record.id} has errors: ${messages.join("; ")}`);
-    }
-}
-/**
- * Check an API response for top-level validation errors (in `meta.errors`)
- * and throw if any are present.
- */
-export function throwOnResponseErrors(response) {
-    const errors = response.meta?.errors;
-    if (!errors || errors.length === 0)
-        return;
-    const messages = errors.map((err) => formatResponseError(err));
-    throw new ZapierValidationError(messages.join("; "));
-}
-export const KeyModeSchema = z
-    .enum(["names", "ids"])
-    .optional()
-    .default("names")
-    .describe('How to interpret field keys in record data. "names" (default) uses human-readable field names, "ids" uses raw field IDs (f1, f2).');
-export const TrashSchema = z
-    .enum(["exclude", "include", "only"])
-    .optional()
-    .describe('Control soft-deleted item visibility. "exclude" (default) returns active items only, "include" returns both active and soft-deleted, "only" returns soft-deleted items only.');
-const FIELD_ID_PATTERN = /^f\d+$/;
-export function isFieldId(key) {
-    return FIELD_ID_PATTERN.test(key);
-}
-export const NESTED_COMPONENTS = {
-    labeled_string: new Set(["value"]),
-    ai_formula: new Set(["value"]),
-    link: new Set(["link", "text"]),
-    linked_record: new Set(["label", "source"]),
-};
-async function getFieldMapping(api, tableId, keyMode) {
-    if (keyMode === "ids") {
-        return null;
-    }
-    // "names" mode — fetch from API
-    const rawResponse = await api.get(`/tables/api/v1/tables/${tableId}/fields`, {
-        authRequired: true,
-        resource: { type: "table", id: tableId },
-    });
-    const data = rawResponse.data;
-    // First match wins for duplicate names
-    const nameToId = new Map();
-    const idToName = new Map();
-    const idToType = new Map();
-    for (const field of data) {
-        const id = `f${field.id}`;
-        if (!nameToId.has(field.name)) {
-            nameToId.set(field.name, id);
-        }
-        if (!idToName.has(id)) {
-            idToName.set(id, field.name);
-        }
-        idToType.set(id, field.type);
-    }
-    return { nameToId, idToName, idToType };
-}
-/**
- * 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 async function resolveFieldKeys({ api, tableId, fieldKeys, }) {
-    const allAreIds = fieldKeys.every((key) => typeof key === "number" || /^(f?\d+)$/.test(key));
-    if (allAreIds) {
-        return fieldKeys.map(toNumericFieldId);
-    }
-    const mapping = await getFieldMapping(api, tableId, "names");
-    if (!mapping) {
-        return fieldKeys.map(toNumericFieldId);
-    }
-    return fieldKeys.map((key) => {
-        if (typeof key === "number")
-            return key;
-        if (FIELD_ID_PATTERN.test(key))
-            return toNumericFieldId(key);
-        const id = mapping.nameToId.get(key);
-        if (!id) {
-            throw new ZapierValidationError(`Unknown field name: "${key}". Use a valid field name or ID.`);
-        }
-        return toNumericFieldId(id);
-    });
-}
-/**
- * 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 async function createFieldKeyTranslator({ api, tableId, keyMode, }) {
-    const mapping = await getFieldMapping(api, tableId, keyMode);
-    return {
-        translateInput(data) {
-            if (!mapping)
-                return data;
-            const result = {};
-            for (const [key, value] of Object.entries(data)) {
-                if (FIELD_ID_PATTERN.test(key) && mapping.idToName.has(key)) {
-                    result[key] = value;
-                }
-                else if (mapping.nameToId.has(key)) {
-                    result[mapping.nameToId.get(key)] = value;
-                }
-                else {
-                    result[key] = value;
-                }
-            }
-            return result;
-        },
-        translateOutput(data) {
-            if (!mapping)
-                return data;
-            const result = {};
-            for (const [key, value] of Object.entries(data)) {
-                if (mapping.idToName.has(key)) {
-                    result[mapping.idToName.get(key)] = value;
-                }
-                else {
-                    result[key] = value;
-                }
-            }
-            return result;
-        },
-        translateFieldKey(key) {
-            if (!mapping)
-                return key;
-            if (FIELD_ID_PATTERN.test(key) && mapping.idToName.has(key)) {
-                // Auto-append component for single-component types (e.g., f3 → f3__value for labeled_string)
-                const fieldType = mapping.idToType.get(key);
-                if (fieldType) {
-                    const components = NESTED_COMPONENTS[fieldType];
-                    if (components?.size === 1) {
-                        return `${key}__${[...components][0]}`;
-                    }
-                }
-                return key;
-            }
-            if (mapping.nameToId.has(key)) {
-                const fieldId = mapping.nameToId.get(key);
-                // Auto-append component for single-component types (e.g., Status → f3__value for labeled_string)
-                const fieldType = mapping.idToType.get(fieldId);
-                if (fieldType) {
-                    const components = NESTED_COMPONENTS[fieldType];
-                    if (components?.size === 1) {
-                        return `${fieldId}__${[...components][0]}`;
-                    }
-                }
-                return fieldId;
-            }
-            // Handle nested component syntax (e.g., "Status__value" → "f3__value")
-            const sepIndex = key.lastIndexOf("__");
-            if (sepIndex > 0) {
-                const prefix = key.slice(0, sepIndex);
-                const component = key.slice(sepIndex + 2);
-                let fieldId;
-                if (FIELD_ID_PATTERN.test(prefix) && mapping.idToName.has(prefix)) {
-                    fieldId = prefix;
-                }
-                else {
-                    fieldId = mapping.nameToId.get(prefix);
-                }
-                if (fieldId) {
-                    const fieldType = mapping.idToType.get(fieldId);
-                    if (fieldType && NESTED_COMPONENTS[fieldType]?.has(component)) {
-                        return `${fieldId}__${component}`;
-                    }
-                }
-            }
-            return key;
-        },
-    };
-}