@zapier/zapier-sdk 0.77.1 → 0.77.2

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

@@ -1,225 +0,0 @@
-import { z } from "zod";
-export declare const FieldTypeSchema: z.ZodEnum<{
-    string: "string";
-    number: "number";
-    boolean: "boolean";
-    text: "text";
-    datetime: "datetime";
-    decimal: "decimal";
-    json: "json";
-    email: "email";
-    link: "link";
-    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";
-    uuid: "uuid";
-    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";
-        text: "text";
-        datetime: "datetime";
-        decimal: "decimal";
-        json: "json";
-        email: "email";
-        link: "link";
-        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";
-        uuid: "uuid";
-        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>;
-    deleted_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-}, 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";
-            text: "text";
-            datetime: "datetime";
-            decimal: "decimal";
-            json: "json";
-            email: "email";
-            link: "link";
-            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";
-            uuid: "uuid";
-            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>;
-        deleted_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    }, 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";
-        text: "text";
-        datetime: "datetime";
-        decimal: "decimal";
-        json: "json";
-        email: "email";
-        link: "link";
-        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";
-        uuid: "uuid";
-        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>>;
-    deleted_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-}, z.core.$strip>;
-export type FieldItem = z.infer<typeof FieldItemSchema>;
-export declare const ListTableFieldsOptionsSchema: z.ZodObject<{
-    table: z.ZodString & {
-        _def: z.core.$ZodStringDef & import("kitcore").PositionalMetadata;
-    };
-    fields: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
-    fieldKeys: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
-    trash: z.ZodOptional<z.ZodEnum<{
-        only: "only";
-        include: "include";
-        exclude: "exclude";
-    }>>;
-}, z.core.$strip>;
-declare const ListTableFieldsOptionsSchemaDeprecated: z.ZodObject<{
-    tableId: z.ZodString;
-    fields: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
-    fieldKeys: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
-    trash: z.ZodOptional<z.ZodEnum<{
-        only: "only";
-        include: "include";
-        exclude: "exclude";
-    }>>;
-}, z.core.$strip>;
-export declare const ListTableFieldsOptionsInputSchema: z.ZodUnion<readonly [z.ZodObject<{
-    table: z.ZodString & {
-        _def: z.core.$ZodStringDef & import("kitcore").PositionalMetadata;
-    };
-    fields: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
-    fieldKeys: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
-    trash: z.ZodOptional<z.ZodEnum<{
-        only: "only";
-        include: "include";
-        exclude: "exclude";
-    }>>;
-}, z.core.$strip>, z.ZodObject<{
-    tableId: z.ZodString;
-    fields: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
-    fieldKeys: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
-    trash: z.ZodOptional<z.ZodEnum<{
-        only: "only";
-        include: "include";
-        exclude: "exclude";
-    }>>;
-}, z.core.$strip>]>;
-export type ListTableFieldsOptions = z.infer<typeof ListTableFieldsOptionsSchema> | (Omit<z.infer<typeof ListTableFieldsOptionsSchemaDeprecated>, "tableId" | "fieldKeys"> & {
-    /** @deprecated Use `table` instead. */
-    tableId: z.infer<typeof ListTableFieldsOptionsSchemaDeprecated>["tableId"];
-    /** @deprecated Use `fields` instead. */
-    fieldKeys?: z.infer<typeof ListTableFieldsOptionsSchemaDeprecated>["fieldKeys"];
-});
-export interface ListTableFieldsResult {
-    data: FieldItem[];
-}
-export interface ListTableFieldsSdkFunction {
-    listTableFields: (options: ListTableFieldsOptions) => Promise<ListTableFieldsResult>;
-}
-export {};
-//# sourceMappingURL=schemas.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/listTableFields/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+B1B,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAY7B,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;AAEF,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAS1B,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAkBxD,eAAO,MAAM,4BAA4B;;;;;;;;;;;iBAMsB,CAAC;AAGhE,QAAA,MAAM,sCAAsC;;;;;;;;;iBAOF,CAAC;AAG3C,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;mBAEP,CAAC;AAGxC,MAAM,MAAM,sBAAsB,GAC9B,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,GAC5C,CAAC,IAAI,CACH,CAAC,CAAC,KAAK,CAAC,OAAO,sCAAsC,CAAC,EACtD,SAAS,GAAG,WAAW,CACxB,GAAG;IACF,uCAAuC;IACvC,OAAO,EAAE,CAAC,CAAC,KAAK,CACd,OAAO,sCAAsC,CAC9C,CAAC,SAAS,CAAC,CAAC;IACb,wCAAwC;IACxC,SAAS,CAAC,EAAE,CAAC,CAAC,KAAK,CACjB,OAAO,sCAAsC,CAC9C,CAAC,WAAW,CAAC,CAAC;CAChB,CAAC,CAAC;AAGP,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,SAAS,EAAE,CAAC;CACnB;AAGD,MAAM,WAAW,0BAA0B;IACzC,eAAe,EAAE,CACf,OAAO,EAAE,sBAAsB,KAC5B,OAAO,CAAC,qBAAqB,CAAC,CAAC;CACrC"}

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

@@ -1,93 +0,0 @@
-import { z } from "zod";
-import { TablePropertySchema, FieldsPropertySchema, } from "../../../types/properties";
-import { TrashSchema } from "../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(),
-    deleted_at: z.string().nullable().optional(),
-});
-export const ListTableFieldsApiResponseSchema = z.object({
-    data: z.array(FieldApiItemSchema),
-});
-export const FieldItemSchema = 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(),
-    deleted_at: z.string().nullable().optional(),
-});
-const ListTableFieldsDescription = "List fields for a table";
-// Base schema with optional fields (new + deprecated)
-const ListTableFieldsOptionsBaseSchema = z.object({
-    fields: FieldsPropertySchema.optional(),
-    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).')
-        .meta({ deprecated: true }),
-    trash: TrashSchema,
-});
-// Schema for docs/registry (new param names only)
-export const ListTableFieldsOptionsSchema = z
-    .object({
-    table: TablePropertySchema,
-})
-    .merge(ListTableFieldsOptionsBaseSchema)
-    .describe(ListTableFieldsDescription)
-    .meta({ aliases: { tableId: "table", fieldKeys: "fields" } });
-// Deprecated schema (backward compat)
-const ListTableFieldsOptionsSchemaDeprecated = 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(ListTableFieldsOptionsBaseSchema);
-// Union for runtime validation
-export const ListTableFieldsOptionsInputSchema = z
-    .union([ListTableFieldsOptionsSchema, ListTableFieldsOptionsSchemaDeprecated])
-    .describe(ListTableFieldsDescription);

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

@@ -1,136 +0,0 @@
-export declare const listTableRecordsPlugin: (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>;
-    };
-}) => {
-    listTableRecords: (options?: (({
-        table: string;
-        keyMode: "names" | "ids";
-        filters?: {
-            fieldKey: string;
-            operator: "in" | "contains" | "gt" | "gte" | "lt" | "lte" | "search" | "exact" | "different" | "icontains" | "range" | "isnull" | "startswith" | "is_within";
-            value?: unknown;
-        }[] | undefined;
-        sort?: {
-            fieldKey: string;
-            direction: "asc" | "desc";
-        } | undefined;
-        pageSize?: number | undefined;
-        maxItems?: number | undefined;
-        cursor?: string | undefined;
-        trash?: "only" | "include" | "exclude" | undefined;
-    } | {
-        tableId: string;
-        keyMode: "names" | "ids";
-        filters?: {
-            fieldKey: string;
-            operator: "in" | "contains" | "gt" | "gte" | "lt" | "lte" | "search" | "exact" | "different" | "icontains" | "range" | "isnull" | "startswith" | "is_within";
-            value?: unknown;
-        }[] | undefined;
-        sort?: {
-            fieldKey: string;
-            direction: "asc" | "desc";
-        } | undefined;
-        pageSize?: number | undefined;
-        maxItems?: number | undefined;
-        cursor?: string | undefined;
-        trash?: "only" | "include" | "exclude" | undefined;
-    }) & {
-        cursor?: string;
-        pageSize?: number;
-        maxItems?: number;
-    }) | undefined) => import("kitcore").PaginatedSdkResult<{
-        data: Record<string, unknown>;
-        id: string;
-        created_at: string;
-        edited_at: string;
-        deleted_at?: string | null | undefined;
-    }>;
-} & {
-    context: {
-        meta: {
-            listTableRecords: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-};
-export type ListTableRecordsPluginProvides = ReturnType<typeof listTableRecordsPlugin>;
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/listTableRecords/index.ts"],"names":[],"mappings":"AAyBA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4FlC,CAAC;AAEF,MAAM,MAAM,8BAA8B,GAAG,UAAU,CACrD,OAAO,sBAAsB,CAC9B,CAAC"}

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

@@ -1,81 +0,0 @@
-import { definePlugin } from "kitcore";
-import { createPaginatedPluginMethod } from "kitcore";
-import { ListTableRecordsApiResponseSchema, ListTableRecordsOptionsInputSchema, RecordItemSchema, } from "./schemas";
-import { tableIdResolver, tableFiltersResolver, tableSortResolver, } from "../../../resolvers";
-import { tableRecordFormatter } from "../../../formatters";
-import { createFieldKeyTranslator, transformRecordItem, throwOnResponseErrors, } from "../utils";
-import { DEFAULT_PAGE_SIZE } from "../../../constants";
-import { tablesDefaults } from "../shared";
-export const listTableRecordsPlugin = definePlugin((sdk) => createPaginatedPluginMethod(sdk, {
-    ...tablesDefaults,
-    name: "listTableRecords",
-    type: "list",
-    itemType: "Record",
-    inputSchema: ListTableRecordsOptionsInputSchema,
-    outputSchema: RecordItemSchema,
-    defaultPageSize: DEFAULT_PAGE_SIZE,
-    resolvers: {
-        table: tableIdResolver,
-        filters: tableFiltersResolver,
-        sort: tableSortResolver,
-    },
-    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 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 searchParams = {
-            allow_nested_queries: "true",
-        };
-        if (options.trash) {
-            searchParams.trash = options.trash;
-        }
-        const rawResponse = await api.post(`/tables/api/v1/tables/${tableId}/records/query`, body, {
-            searchParams,
-            authRequired: true,
-            resource: { type: "table", id: tableId },
-        });
-        throwOnResponseErrors(rawResponse);
-        const response = ListTableRecordsApiResponseSchema.parse(rawResponse);
-        const pagination = response.meta?.pagination;
-        const nextCursor = pagination?.has_more && pagination.end_cursor
-            ? pagination.end_cursor
-            : undefined;
-        return {
-            data: response.data.map((item) => ({
-                ...transformRecordItem(item),
-                data: translator.translateOutput(item.data),
-            })),
-            nextCursor,
-        };
-    },
-}));