@zapier/zapier-sdk 0.34.1 → 0.36.0

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;AA6BhE,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,CA+G/B,CAAC"}

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

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

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;AAsBhE,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,CAsFzB,CAAC"}