@zapier/zapier-sdk 0.34.0 → 0.35.0

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

@@ -0,0 +1,51 @@
+import { z } from "zod";
+import type { FunctionOptions } from "../../../types/functions";
+import type { ZapierAuthenticationError, ZapierApiError, ZapierValidationError, ZapierUnknownError } from "../../../types/errors";
+export declare const RecordApiItemSchema: 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>;
+export type RecordApiItem = z.infer<typeof RecordApiItemSchema>;
+export declare const RecordItemSchema: z.ZodObject<{
+    id: z.ZodString;
+    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    created_at: z.ZodString;
+    edited_at: z.ZodString;
+}, z.core.$strip>;
+export type RecordItem = z.infer<typeof RecordItemSchema>;
+export declare const GetTableRecordApiResponseSchema: z.ZodObject<{
+    data: 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>;
+}, z.core.$strip>;
+export type GetTableRecordApiResponse = z.infer<typeof GetTableRecordApiResponseSchema>;
+export declare const GetTableRecordOptionsSchema: z.ZodObject<{
+    tableId: z.ZodString;
+    recordId: z.ZodString;
+    keyMode: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        names: "names";
+        ids: "ids";
+    }>>>;
+}, z.core.$strip>;
+export type GetTableRecordOptions = z.infer<typeof GetTableRecordOptionsSchema> & FunctionOptions;
+export interface GetTableRecordResult {
+    data: RecordItem;
+}
+export type GetTableRecordError = ZapierAuthenticationError | ZapierApiError | ZapierValidationError | ZapierUnknownError;
+export interface GetTableRecordSdkFunction {
+    getTableRecord: (options: GetTableRecordOptions) => Promise<GetTableRecordResult>;
+}
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/getTableRecord/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;AAI/B,eAAO,MAAM,mBAAmB;;;;;;;;;iBAS9B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAUhE,eAAO,MAAM,gBAAgB;;;;;iBAO3B,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D,eAAO,MAAM,+BAA+B;;;;;;;;;;;iBAE1C,CAAC;AAEH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAC7C,OAAO,+BAA+B,CACvC,CAAC;AAEF,eAAO,MAAM,2BAA2B;;;;;;;iBAYa,CAAC;AAEtD,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CACzC,OAAO,2BAA2B,CACnC,GACC,eAAe,CAAC;AAElB,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,UAAU,CAAC;CAClB;AAED,MAAM,MAAM,mBAAmB,GAC3B,yBAAyB,GACzB,cAAc,GACd,qBAAqB,GACrB,kBAAkB,CAAC;AAEvB,MAAM,WAAW,yBAAyB;IACxC,cAAc,EAAE,CACd,OAAO,EAAE,qBAAqB,KAC3B,OAAO,CAAC,oBAAoB,CAAC,CAAC;CACpC"}

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

@@ -0,0 +1,44 @@
+import { z } from "zod";
+import { withFormatter } from "../../../utils/schema-utils";
+import { KeyModeSchema } from "../utils";
+export const RecordApiItemSchema = z.object({
+    id: z.string().regex(/^[A-Z0-9]{26}$/, "Record ID must be a valid ULID"),
+    data: z.record(z.string(), z.unknown()),
+    created_at: z.string(),
+    edited_at: z.string(),
+    schema_revision_id: z.number(),
+    errors: z.record(z.string(), z.unknown()).nullable().optional(),
+    orig_data: z.record(z.string(), z.unknown()).nullable().optional(),
+    is_source_record: z.boolean().nullable().optional(),
+});
+// SDK output schema (simplified)
+const RecordItemSchemaBase = z.object({
+    id: z.string(),
+    data: z.record(z.string(), z.unknown()),
+    created_at: z.string(),
+    edited_at: z.string(),
+});
+export const RecordItemSchema = withFormatter(RecordItemSchemaBase, {
+    format: (item) => ({
+        title: `Record ${item.id}`,
+        id: item.id,
+        data: item.data,
+        details: [],
+    }),
+});
+export const GetTableRecordApiResponseSchema = z.object({
+    data: RecordApiItemSchema,
+});
+export const GetTableRecordOptionsSchema = z
+    .object({
+    tableId: z
+        .string()
+        .regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID")
+        .describe("The unique identifier of the table"),
+    recordId: z
+        .string()
+        .regex(/^[A-Z0-9]{26}$/, "Record ID must be a valid ULID")
+        .describe("The unique identifier of the record"),
+    keyMode: KeyModeSchema,
+})
+    .describe("Get a single record from a table by ID");

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

@@ -0,0 +1,18 @@
+import type { Plugin } from "../../../types/plugin";
+import type { ApiClient } from "../../../api";
+import { ListTableFieldsOptionsSchema, type ListTableFieldsOptions, type ListTableFieldsResult } from "./schemas";
+import type { EventEmissionContext } from "../../eventEmission";
+export interface ListTableFieldsPluginProvides {
+    listTableFields: (options: ListTableFieldsOptions) => Promise<ListTableFieldsResult>;
+    context: {
+        meta: {
+            listTableFields: {
+                inputSchema: typeof ListTableFieldsOptionsSchema;
+            };
+        };
+    };
+}
+export declare const listTableFieldsPlugin: Plugin<{}, {
+    api: ApiClient;
+} & EventEmissionContext, ListTableFieldsPluginProvides>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/listTableFields/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,4BAA4B,EAG5B,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAC3B,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAMhE,MAAM,WAAW,6BAA6B;IAC5C,eAAe,EAAE,CACf,OAAO,EAAE,sBAAsB,KAC5B,OAAO,CAAC,qBAAqB,CAAC,CAAC;IACpC,OAAO,EAAE;QACP,IAAI,EAAE;YACJ,eAAe,EAAE;gBACf,WAAW,EAAE,OAAO,4BAA4B,CAAC;aAClD,CAAC;SACH,CAAC;KACH,CAAC;CACH;AAED,eAAO,MAAM,qBAAqB,EAAE,MAAM,CACxC,EAAE,EACF;IAAE,GAAG,EAAE,SAAS,CAAA;CAAE,GAAG,oBAAoB,EACzC,6BAA6B,CA6E9B,CAAC"}

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

@@ -0,0 +1,58 @@
+import { createFunction } from "../../../utils/function-utils";
+import { ListTableFieldsOptionsSchema, ListTableFieldsApiResponseSchema, FieldItemSchema, } from "./schemas";
+import { createTelemetryCallback } from "../../../utils/telemetry-utils";
+import { ZapierAuthenticationError } from "../../../types/errors";
+import { tableIdResolver } from "../../../resolvers";
+import { resolveFieldKeys, transformFieldItem } from "../utils";
+export const listTableFieldsPlugin = ({ context }) => {
+    async function listTableFields(options) {
+        const { api } = context;
+        const searchParams = {};
+        if (options.fieldKeys && options.fieldKeys.length > 0) {
+            const numericIds = await resolveFieldKeys({
+                api,
+                tableId: options.tableId,
+                fieldKeys: options.fieldKeys,
+            });
+            searchParams.field_ids = numericIds.join(",");
+        }
+        const rawResponse = await api.get(`/tables/api/v1/tables/${options.tableId}/fields`, {
+            searchParams: Object.keys(searchParams).length > 0 ? searchParams : undefined,
+            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 = ListTableFieldsApiResponseSchema.parse(rawResponse);
+        return {
+            data: response.data.map(transformFieldItem),
+        };
+    }
+    const listTableFieldsDefinition = createFunction(listTableFields, ListTableFieldsOptionsSchema, createTelemetryCallback(context.eventEmission.emitMethodCalled, listTableFields.name));
+    return {
+        listTableFields: listTableFieldsDefinition,
+        context: {
+            meta: {
+                listTableFields: {
+                    categories: ["table"],
+                    type: "list",
+                    itemType: "Field",
+                    inputSchema: ListTableFieldsOptionsSchema,
+                    outputSchema: FieldItemSchema,
+                    resolvers: {
+                        tableId: tableIdResolver,
+                    },
+                },
+            },
+        },
+    };
+};

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

@@ -0,0 +1,180 @@
+import { z } from "zod";
+import type { FunctionOptions } from "../../../types/functions";
+import type { ZapierAuthenticationError, ZapierApiError, ZapierValidationError, ZapierUnknownError } from "../../../types/errors";
+export declare const FieldTypeSchema: z.ZodEnum<{
+    string: "string";
+    number: "number";
+    boolean: "boolean";
+    link: "link";
+    email: "email";
+    uuid: "uuid";
+    text: "text";
+    datetime: "datetime";
+    decimal: "decimal";
+    json: "json";
+    multiple_string: "multiple_string";
+    labeled_string: "labeled_string";
+    multiple_labeled_string: "multiple_labeled_string";
+    multiple_text: "multiple_text";
+    multiple_boolean: "multiple_boolean";
+    multiple_number: "multiple_number";
+    multiple_decimal: "multiple_decimal";
+    multiple_datetime: "multiple_datetime";
+    multiple_uuid: "multiple_uuid";
+    multiple_json: "multiple_json";
+    formula: "formula";
+    button_trigger_zap: "button_trigger_zap";
+    button_continue_zap: "button_continue_zap";
+    multiple_email: "multiple_email";
+    multiple_link: "multiple_link";
+    currency: "currency";
+    phone_number: "phone_number";
+    ai_formula: "ai_formula";
+    linked_record: "linked_record";
+    multiple_linked_record: "multiple_linked_record";
+}>;
+export type FieldType = z.infer<typeof FieldTypeSchema>;
+export declare const FieldApiItemSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        link: "link";
+        email: "email";
+        uuid: "uuid";
+        text: "text";
+        datetime: "datetime";
+        decimal: "decimal";
+        json: "json";
+        multiple_string: "multiple_string";
+        labeled_string: "labeled_string";
+        multiple_labeled_string: "multiple_labeled_string";
+        multiple_text: "multiple_text";
+        multiple_boolean: "multiple_boolean";
+        multiple_number: "multiple_number";
+        multiple_decimal: "multiple_decimal";
+        multiple_datetime: "multiple_datetime";
+        multiple_uuid: "multiple_uuid";
+        multiple_json: "multiple_json";
+        formula: "formula";
+        button_trigger_zap: "button_trigger_zap";
+        button_continue_zap: "button_continue_zap";
+        multiple_email: "multiple_email";
+        multiple_link: "multiple_link";
+        currency: "currency";
+        phone_number: "phone_number";
+        ai_formula: "ai_formula";
+        linked_record: "linked_record";
+        multiple_linked_record: "multiple_linked_record";
+    }>;
+    name: z.ZodString;
+    created_at: z.ZodOptional<z.ZodString>;
+    edited_at: z.ZodOptional<z.ZodString>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    is_order_field: z.ZodOptional<z.ZodBoolean>;
+    is_filter_field: z.ZodOptional<z.ZodBoolean>;
+    is_selected_field: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type FieldApiItem = z.infer<typeof FieldApiItemSchema>;
+export declare const ListTableFieldsApiResponseSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+            link: "link";
+            email: "email";
+            uuid: "uuid";
+            text: "text";
+            datetime: "datetime";
+            decimal: "decimal";
+            json: "json";
+            multiple_string: "multiple_string";
+            labeled_string: "labeled_string";
+            multiple_labeled_string: "multiple_labeled_string";
+            multiple_text: "multiple_text";
+            multiple_boolean: "multiple_boolean";
+            multiple_number: "multiple_number";
+            multiple_decimal: "multiple_decimal";
+            multiple_datetime: "multiple_datetime";
+            multiple_uuid: "multiple_uuid";
+            multiple_json: "multiple_json";
+            formula: "formula";
+            button_trigger_zap: "button_trigger_zap";
+            button_continue_zap: "button_continue_zap";
+            multiple_email: "multiple_email";
+            multiple_link: "multiple_link";
+            currency: "currency";
+            phone_number: "phone_number";
+            ai_formula: "ai_formula";
+            linked_record: "linked_record";
+            multiple_linked_record: "multiple_linked_record";
+        }>;
+        name: z.ZodString;
+        created_at: z.ZodOptional<z.ZodString>;
+        edited_at: z.ZodOptional<z.ZodString>;
+        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        is_order_field: z.ZodOptional<z.ZodBoolean>;
+        is_filter_field: z.ZodOptional<z.ZodBoolean>;
+        is_selected_field: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ListTableFieldsApiResponse = z.infer<typeof ListTableFieldsApiResponseSchema>;
+export declare const FieldItemSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        link: "link";
+        email: "email";
+        uuid: "uuid";
+        text: "text";
+        datetime: "datetime";
+        decimal: "decimal";
+        json: "json";
+        multiple_string: "multiple_string";
+        labeled_string: "labeled_string";
+        multiple_labeled_string: "multiple_labeled_string";
+        multiple_text: "multiple_text";
+        multiple_boolean: "multiple_boolean";
+        multiple_number: "multiple_number";
+        multiple_decimal: "multiple_decimal";
+        multiple_datetime: "multiple_datetime";
+        multiple_uuid: "multiple_uuid";
+        multiple_json: "multiple_json";
+        formula: "formula";
+        button_trigger_zap: "button_trigger_zap";
+        button_continue_zap: "button_continue_zap";
+        multiple_email: "multiple_email";
+        multiple_link: "multiple_link";
+        currency: "currency";
+        phone_number: "phone_number";
+        ai_formula: "ai_formula";
+        linked_record: "linked_record";
+        multiple_linked_record: "multiple_linked_record";
+    }>;
+    name: z.ZodString;
+    created_at: z.ZodOptional<z.ZodString>;
+    edited_at: z.ZodOptional<z.ZodString>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type FieldItem = z.infer<typeof FieldItemSchema>;
+export declare const ListTableFieldsOptionsSchema: z.ZodObject<{
+    tableId: z.ZodString;
+    fieldKeys: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+}, z.core.$strip>;
+export type ListTableFieldsOptions = z.infer<typeof ListTableFieldsOptionsSchema> & FunctionOptions;
+export interface ListTableFieldsResult {
+    data: FieldItem[];
+}
+export type ListTableFieldsError = ZapierAuthenticationError | ZapierApiError | ZapierValidationError | ZapierUnknownError;
+export interface ListTableFieldsSdkFunction {
+    listTableFields: (options: ListTableFieldsOptions) => Promise<ListTableFieldsResult>;
+}
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/listTableFields/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;AAG/B,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+B1B,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAW7B,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAE3C,CAAC;AAEH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAC9C,OAAO,gCAAgC,CACxC,CAAC;AAYF,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAM1B,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD,eAAO,MAAM,4BAA4B;;;iBAaH,CAAC;AAEvC,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAC1C,OAAO,4BAA4B,CACpC,GACC,eAAe,CAAC;AAGlB,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,SAAS,EAAE,CAAC;CACnB;AAGD,MAAM,MAAM,oBAAoB,GAC5B,yBAAyB,GACzB,cAAc,GACd,qBAAqB,GACrB,kBAAkB,CAAC;AAGvB,MAAM,WAAW,0BAA0B;IACzC,eAAe,EAAE,CACf,OAAO,EAAE,sBAAsB,KAC5B,OAAO,CAAC,qBAAqB,CAAC,CAAC;CACrC"}

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

@@ -0,0 +1,77 @@
+import { z } from "zod";
+import { withFormatter } from "../../../utils/schema-utils";
+export const FieldTypeSchema = z.enum([
+    "string",
+    "multiple_string",
+    "labeled_string",
+    "multiple_labeled_string",
+    "text",
+    "multiple_text",
+    "boolean",
+    "multiple_boolean",
+    "number",
+    "multiple_number",
+    "decimal",
+    "multiple_decimal",
+    "datetime",
+    "multiple_datetime",
+    "uuid",
+    "multiple_uuid",
+    "json",
+    "multiple_json",
+    "formula",
+    "button_trigger_zap",
+    "button_continue_zap",
+    "email",
+    "multiple_email",
+    "link",
+    "multiple_link",
+    "currency",
+    "phone_number",
+    "ai_formula",
+    "linked_record",
+    "multiple_linked_record",
+]);
+export const FieldApiItemSchema = z.object({
+    id: z.number(),
+    type: FieldTypeSchema,
+    name: z.string(),
+    created_at: z.string().optional(),
+    edited_at: z.string().optional(),
+    options: z.record(z.string(), z.unknown()).optional(),
+    config: z.record(z.string(), z.unknown()).optional(),
+    is_order_field: z.boolean().optional(),
+    is_filter_field: z.boolean().optional(),
+    is_selected_field: z.boolean().optional(),
+});
+export const ListTableFieldsApiResponseSchema = z.object({
+    data: z.array(FieldApiItemSchema),
+});
+const FieldItemSchemaBase = z.object({
+    id: z.string(),
+    type: FieldTypeSchema,
+    name: z.string(),
+    created_at: z.string().optional(),
+    edited_at: z.string().optional(),
+    options: z.record(z.string(), z.unknown()).optional(),
+    config: z.record(z.string(), z.unknown()).optional(),
+});
+export const FieldItemSchema = withFormatter(FieldItemSchemaBase, {
+    format: (item) => ({
+        title: item.name,
+        id: item.id,
+        details: [{ text: `Type: ${item.type}`, style: "dim" }],
+    }),
+});
+export const ListTableFieldsOptionsSchema = 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()]))
+        .optional()
+        .describe('Filter by specific fields. Accepts field names (e.g., "Email") or IDs (e.g., "f6", "6", or 6).'),
+})
+    .describe("List fields for a table");

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/listTableRecords/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAEpE,OAAO,EAEL,6BAA6B,EAE7B,KAAK,uBAAuB,EAC5B,KAAK,UAAU,EAChB,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AACnD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AA4BhE,MAAM,WAAW,8BAA8B;IAC7C,gBAAgB,EAAE,CAAC,OAAO,EAAE,uBAAuB,KAAK,OAAO,CAAC;QAC9D,IAAI,EAAE,UAAU,EAAE,CAAC;QACnB,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,CAAC,GACA,aAAa,CAAC;QAAE,IAAI,EAAE,UAAU,EAAE,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,GAAG;QAC3D,KAAK,IAAI,aAAa,CAAC,UAAU,CAAC,CAAC;KACpC,CAAC;IACJ,OAAO,EAAE;QACP,IAAI,EAAE;YACJ,gBAAgB,EAAE;gBAChB,WAAW,EAAE,OAAO,6BAA6B,CAAC;aACnD,CAAC;SACH,CAAC;KACH,CAAC;CACH;AAED,eAAO,MAAM,sBAAsB,EAAE,MAAM,CACzC,EAAE,EACF,cAAc,CAAC,iBAAiB,CAAC,GAAG,oBAAoB,EACxD,8BAA8B,CA6G/B,CAAC"}

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

@@ -0,0 +1,95 @@
+import { createPaginatedFunction } from "../../../utils/function-utils";
+import { ListTableRecordsApiResponseSchema, ListTableRecordsOptionsSchema, RecordItemSchema, } from "./schemas";
+import { createTelemetryCallback } from "../../../utils/telemetry-utils";
+import { stripPageSuffix } from "../../../utils/string-utils";
+import { ZapierAuthenticationError } from "../../../types/errors";
+import { tableIdResolver, tableFiltersResolver, tableSortResolver, } from "../../../resolvers";
+import { tableRecordFormatter } from "../../../formatters";
+import { createFieldKeyTranslator, transformRecordItem, throwOnResponseErrors, } from "../utils";
+function extractNextCursor(meta) {
+    if (!meta?.pagination?.has_more || !meta.pagination.end_cursor) {
+        return undefined;
+    }
+    return meta.pagination.end_cursor;
+}
+export const listTableRecordsPlugin = ({ context }) => {
+    async function listTableRecordsPage(options) {
+        const { api } = context;
+        const translator = await createFieldKeyTranslator({
+            api,
+            tableId: options.tableId,
+            keyMode: options.keyMode,
+        });
+        const body = {
+            limit: options.pageSize,
+        };
+        if (options.filters) {
+            body.filters = options.filters.map((f) => ({
+                key: translator.translateFieldKey(f.fieldKey),
+                operator: f.operator,
+                value: f.value,
+            }));
+        }
+        if (options.sort) {
+            body.orders = [
+                {
+                    key: translator.translateFieldKey(options.sort.fieldKey),
+                    direction: options.sort.direction,
+                },
+            ];
+        }
+        if (options.cursor) {
+            body.cursor_query = {
+                query_type: "window",
+                start_cursor: options.cursor,
+            };
+        }
+        const rawResponse = await api.post(`/tables/api/v1/tables/${options.tableId}/records/query`, body, {
+            searchParams: { allow_nested_queries: "true" },
+            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,
+        });
+        throwOnResponseErrors(rawResponse);
+        const response = ListTableRecordsApiResponseSchema.parse(rawResponse);
+        return {
+            data: response.data.map((item) => ({
+                ...transformRecordItem(item),
+                data: translator.translateOutput(item.data),
+            })),
+            nextCursor: extractNextCursor(response.meta),
+        };
+    }
+    const methodName = stripPageSuffix(listTableRecordsPage.name);
+    const listTableRecordsDefinition = createPaginatedFunction(listTableRecordsPage, ListTableRecordsOptionsSchema, createTelemetryCallback(context.eventEmission.emitMethodCalled, methodName), methodName);
+    return {
+        listTableRecords: listTableRecordsDefinition,
+        context: {
+            meta: {
+                listTableRecords: {
+                    categories: ["table"],
+                    type: "list",
+                    itemType: "Record",
+                    inputSchema: ListTableRecordsOptionsSchema,
+                    outputSchema: RecordItemSchema,
+                    resolvers: {
+                        tableId: tableIdResolver,
+                        filters: tableFiltersResolver,
+                        sort: tableSortResolver,
+                    },
+                    formatter: tableRecordFormatter,
+                },
+            },
+        },
+    };
+};