@zapier/zapier-sdk 0.77.1 → 0.78.0

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

@@ -1,256 +0,0 @@
-import { z } from "zod";
-import type { PaginatedSdkFunction } from "../../../types/functions";
-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>>;
-        deleted_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    }, 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";
-    contains: "contains";
-    gt: "gt";
-    gte: "gte";
-    lt: "lt";
-    lte: "lte";
-    search: "search";
-    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";
-        contains: "contains";
-        gt: "gt";
-        gte: "gte";
-        lt: "lt";
-        lte: "lte";
-        search: "search";
-        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<{
-    table: z.ZodString & {
-        _def: z.core.$ZodStringDef & import("kitcore").PositionalMetadata;
-    };
-    filters: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        fieldKey: z.ZodString;
-        operator: z.ZodEnum<{
-            in: "in";
-            contains: "contains";
-            gt: "gt";
-            gte: "gte";
-            lt: "lt";
-            lte: "lte";
-            search: "search";
-            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";
-    }>>>;
-    trash: z.ZodOptional<z.ZodEnum<{
-        only: "only";
-        include: "include";
-        exclude: "exclude";
-    }>>;
-}, z.core.$strip>;
-declare const ListTableRecordsOptionsSchemaDeprecated: z.ZodObject<{
-    tableId: z.ZodString;
-    filters: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        fieldKey: z.ZodString;
-        operator: z.ZodEnum<{
-            in: "in";
-            contains: "contains";
-            gt: "gt";
-            gte: "gte";
-            lt: "lt";
-            lte: "lte";
-            search: "search";
-            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";
-    }>>>;
-    trash: z.ZodOptional<z.ZodEnum<{
-        only: "only";
-        include: "include";
-        exclude: "exclude";
-    }>>;
-}, z.core.$strip>;
-export declare const ListTableRecordsOptionsInputSchema: z.ZodUnion<readonly [z.ZodObject<{
-    table: z.ZodString & {
-        _def: z.core.$ZodStringDef & import("kitcore").PositionalMetadata;
-    };
-    filters: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        fieldKey: z.ZodString;
-        operator: z.ZodEnum<{
-            in: "in";
-            contains: "contains";
-            gt: "gt";
-            gte: "gte";
-            lt: "lt";
-            lte: "lte";
-            search: "search";
-            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";
-    }>>>;
-    trash: z.ZodOptional<z.ZodEnum<{
-        only: "only";
-        include: "include";
-        exclude: "exclude";
-    }>>;
-}, z.core.$strip>, z.ZodObject<{
-    tableId: z.ZodString;
-    filters: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        fieldKey: z.ZodString;
-        operator: z.ZodEnum<{
-            in: "in";
-            contains: "contains";
-            gt: "gt";
-            gte: "gte";
-            lt: "lt";
-            lte: "lte";
-            search: "search";
-            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";
-    }>>>;
-    trash: z.ZodOptional<z.ZodEnum<{
-        only: "only";
-        include: "include";
-        exclude: "exclude";
-    }>>;
-}, z.core.$strip>]>;
-export type ListTableRecordsOptions = z.infer<typeof ListTableRecordsOptionsSchema> | (Omit<z.infer<typeof ListTableRecordsOptionsSchemaDeprecated>, "tableId"> & {
-    /** @deprecated Use `table` instead. */
-    tableId: z.infer<typeof ListTableRecordsOptionsSchemaDeprecated>["tableId"];
-});
-export interface ListTableRecordsPage {
-    data: RecordItem[];
-    nextCursor?: string;
-}
-export interface ListTableRecordsSdkFunction {
-    listTableRecords: PaginatedSdkFunction<ListTableRecordsOptions, RecordItem>;
-}
-//# sourceMappingURL=schemas.d.ts.map

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

@@ -1 +0,0 @@
-{"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;AAErE,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;AA4BhE,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAMA,CAAC;AAG3C,QAAA,MAAM,uCAAuC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAOf,CAAC;AAG/B,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAKP,CAAC;AAGzC,MAAM,MAAM,uBAAuB,GAC/B,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,GAC7C,CAAC,IAAI,CACH,CAAC,CAAC,KAAK,CAAC,OAAO,uCAAuC,CAAC,EACvD,SAAS,CACV,GAAG;IACF,uCAAuC;IACvC,OAAO,EAAE,CAAC,CAAC,KAAK,CACd,OAAO,uCAAuC,CAC/C,CAAC,SAAS,CAAC,CAAC;CACd,CAAC,CAAC;AAEP,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,UAAU,EAAE,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,2BAA2B;IAC1C,gBAAgB,EAAE,oBAAoB,CAAC,uBAAuB,EAAE,UAAU,CAAC,CAAC;CAC7E"}

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

@@ -1,95 +0,0 @@
-import { z } from "zod";
-import { TablePropertySchema } from "../../../types/properties";
-import { RecordApiItemSchema, RecordItemSchema, } from "../getTableRecord/schemas";
-import { KeyModeSchema, TrashSchema } 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"),
-});
-const ListTableRecordsDescription = "List records in a table with optional filtering and sorting";
-const ListTableRecordsBase = z.object({
-    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,
-    trash: TrashSchema,
-});
-// Schema for docs/registry (new param names only)
-export const ListTableRecordsOptionsSchema = z
-    .object({
-    table: TablePropertySchema,
-})
-    .merge(ListTableRecordsBase)
-    .describe(ListTableRecordsDescription)
-    .meta({ aliases: { tableId: "table" } });
-// Deprecated schema (backward compat)
-const ListTableRecordsOptionsSchemaDeprecated = 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(ListTableRecordsBase);
-// Union for runtime validation
-export const ListTableRecordsOptionsInputSchema = z
-    .union([
-    ListTableRecordsOptionsSchema,
-    ListTableRecordsOptionsSchemaDeprecated,
-])
-    .describe(ListTableRecordsDescription);

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

@@ -1,60 +0,0 @@
-import type { CapabilitiesContext } from "../../capabilities";
-export declare const listTablesPlugin: (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;
-} & {
-    context: CapabilitiesContext;
-} & {
-    context: {
-        meta: Record<string, import("kitcore").PluginMeta>;
-    };
-}) => {
-    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>;
-        };
-    };
-};
-export type ListTablesPluginProvides = ReturnType<typeof listTablesPlugin>;
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/listTables/index.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAM9D,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;aAGY,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoE3D,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

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

@@ -1,67 +0,0 @@
-import { definePlugin } from "kitcore";
-import { createPaginatedPluginMethod } from "kitcore";
-import { ListTablesApiResponseSchema, ListTablesOptionsSchema, TableItemSchema, } from "./schemas";
-import { ZapierValidationError } from "../../../types/errors";
-import { transformTableItem } from "../utils";
-import { DEFAULT_PAGE_SIZE } from "../../../constants";
-import { tablesDefaults } from "../shared";
-import { zapierPagination } from "../../../utils/pagination";
-export const listTablesPlugin = definePlugin((sdk) => createPaginatedPluginMethod(sdk, {
-    ...tablesDefaults,
-    ...zapierPagination,
-    name: "listTables",
-    type: "list",
-    itemType: "Table",
-    inputSchema: ListTablesOptionsSchema,
-    outputSchema: TableItemSchema,
-    defaultPageSize: DEFAULT_PAGE_SIZE,
-    handler: async ({ sdk, options }) => {
-        if (options.includeShared) {
-            await sdk.context.checkCapability("canIncludeSharedTables");
-        }
-        const { api } = sdk.context;
-        const searchParams = {};
-        if (options.pageSize !== undefined) {
-            searchParams.limit = options.pageSize.toString();
-        }
-        const tableIds = "tables" in options && options.tables
-            ? options.tables
-            : options.tableIds;
-        if (tableIds && tableIds.length > 0) {
-            searchParams.ids = tableIds.join(",");
-        }
-        if (options.kind) {
-            searchParams.kind = options.kind;
-        }
-        if (options.search) {
-            searchParams.q = options.search;
-        }
-        if (options.owner && options.owner !== "me" && !options.includeShared) {
-            throw new ZapierValidationError('The "owner" option requires "includeShared" to be true. Without includeShared, only your own tables are returned.');
-        }
-        const owner = options.includeShared ? options.owner : "me";
-        if (owner) {
-            if (owner === "me") {
-                const profile = await api.get("/zapier/api/v4/profile/", {
-                    authRequired: true,
-                });
-                searchParams.owner_customuser_id = String(profile.id);
-            }
-            else {
-                searchParams.owner_customuser_id = owner;
-            }
-        }
-        if (options.cursor) {
-            searchParams.offset = options.cursor;
-        }
-        const rawResponse = await api.get("/tables/api/v1/tables", {
-            searchParams,
-            authRequired: true,
-        });
-        const response = ListTablesApiResponseSchema.parse(rawResponse);
-        return {
-            data: response.data.map(transformTableItem),
-            links: response.links,
-        };
-    },
-}));

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

@@ -1,85 +0,0 @@
-import { z } from "zod";
-import type { PaginatedSdkFunction } from "../../../types/functions";
-export declare const TableApiItemSchema: z.ZodObject<{
-    id: z.ZodString;
-    name: z.ZodString;
-    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    created_at: z.ZodString;
-    edited_at: z.ZodString;
-    kind: z.ZodEnum<{
-        table: "table";
-        virtual_table: "virtual_table";
-    }>;
-    owner_account_id: z.ZodNumber;
-    owner_account_public_id: z.ZodOptional<z.ZodString>;
-    owner_user_id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-    owner_zapier_customuser_id: z.ZodNumber;
-    owner_zapier_customuser_public_id: z.ZodOptional<z.ZodString>;
-    parent_table_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-}, z.core.$strip>;
-export type TableApiItem = z.infer<typeof TableApiItemSchema>;
-export declare const ListTablesApiResponseSchema: z.ZodObject<{
-    data: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        name: z.ZodString;
-        description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        created_at: z.ZodString;
-        edited_at: z.ZodString;
-        kind: z.ZodEnum<{
-            table: "table";
-            virtual_table: "virtual_table";
-        }>;
-        owner_account_id: z.ZodNumber;
-        owner_account_public_id: z.ZodOptional<z.ZodString>;
-        owner_user_id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-        owner_zapier_customuser_id: z.ZodNumber;
-        owner_zapier_customuser_public_id: z.ZodOptional<z.ZodString>;
-        parent_table_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    }, z.core.$strip>>;
-    links: z.ZodOptional<z.ZodObject<{
-        next: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type ListTablesApiResponse = z.infer<typeof ListTablesApiResponseSchema>;
-export declare const TableItemSchema: z.ZodObject<{
-    id: z.ZodString;
-    name: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    created_at: z.ZodString;
-    edited_at: z.ZodString;
-    kind: z.ZodEnum<{
-        table: "table";
-        virtual_table: "virtual_table";
-    }>;
-    account_id: z.ZodString;
-    profile_id: z.ZodString;
-    parent_table_id: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export type TableItem = z.infer<typeof TableItemSchema>;
-export declare const ListTablesOptionsSchema: z.ZodObject<{
-    tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    tableIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    kind: z.ZodOptional<z.ZodEnum<{
-        table: "table";
-        virtual_table: "virtual_table";
-        both: "both";
-    }>>;
-    search: z.ZodOptional<z.ZodString>;
-    owner: z.ZodOptional<z.ZodString>;
-    includeShared: z.ZodOptional<z.ZodBoolean>;
-    pageSize: z.ZodOptional<z.ZodNumber>;
-    maxItems: z.ZodOptional<z.ZodNumber>;
-    cursor: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export type ListTablesOptions = Omit<z.infer<typeof ListTablesOptionsSchema>, "tableIds"> & {
-    /** @deprecated Use `tables` instead. */
-    tableIds?: z.infer<typeof ListTablesOptionsSchema>["tableIds"];
-};
-export interface ListTablesPage {
-    data: TableItem[];
-    nextCursor?: string;
-}
-export interface ListTablesSdkFunction {
-    listTables: PaginatedSdkFunction<ListTablesOptions, TableItem>;
-}
-//# sourceMappingURL=schemas.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/listTables/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAGrE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;iBAa7B,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;iBAOtC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,eAAO,MAAM,eAAe;;;;;;;;;;;;;iBAU1B,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;iBAwC0B,CAAC;AAE/D,MAAM,MAAM,iBAAiB,GAAG,IAAI,CAClC,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,EACvC,UAAU,CACX,GAAG;IACF,wCAAwC;IACxC,QAAQ,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC,UAAU,CAAC,CAAC;CAChE,CAAC;AAGF,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,SAAS,EAAE,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAGD,MAAM,WAAW,qBAAqB;IACpC,UAAU,EAAE,oBAAoB,CAAC,iBAAiB,EAAE,SAAS,CAAC,CAAC;CAChE"}

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

@@ -1,72 +0,0 @@
-import { z } from "zod";
-import { TablesPropertySchema } from "../../../types/properties";
-export const TableApiItemSchema = z.object({
-    id: z.string(),
-    name: z.string(),
-    description: z.string().nullable().optional(),
-    created_at: z.string(),
-    edited_at: z.string(),
-    kind: z.enum(["table", "virtual_table"]),
-    owner_account_id: z.number(),
-    owner_account_public_id: z.string().optional(),
-    owner_user_id: z.number().nullable().optional(),
-    owner_zapier_customuser_id: z.number(),
-    owner_zapier_customuser_public_id: z.string().optional(),
-    parent_table_id: z.string().nullable().optional(),
-});
-export const ListTablesApiResponseSchema = z.object({
-    data: z.array(TableApiItemSchema),
-    links: z
-        .object({
-        next: z.string().nullable().optional(),
-    })
-        .optional(),
-});
-export const TableItemSchema = z.object({
-    id: z.string(),
-    name: z.string(),
-    description: z.string().optional(),
-    created_at: z.string(),
-    edited_at: z.string(),
-    kind: z.enum(["table", "virtual_table"]),
-    account_id: z.string(),
-    profile_id: z.string(),
-    parent_table_id: z.string().optional(),
-});
-export const ListTablesOptionsSchema = z
-    .object({
-    tables: TablesPropertySchema.optional(),
-    tableIds: z
-        .array(z.string())
-        .optional()
-        .describe("Filter by specific table IDs")
-        .meta({ deprecated: true }),
-    kind: z
-        .enum(["table", "virtual_table", "both"])
-        .optional()
-        .describe("Filter by table type"),
-    search: z
-        .string()
-        .optional()
-        .describe("Search term to filter tables by name"),
-    owner: z
-        .string()
-        .optional()
-        .describe('Filter by table owner. Use "me" for the current user, or a numeric user ID. Requires includeShared to be true.'),
-    includeShared: z
-        .boolean()
-        .optional()
-        .describe("Include tables shared with you. Without this, only your own tables are returned."),
-    pageSize: z
-        .number()
-        .min(1)
-        .optional()
-        .describe("Number of tables per page"),
-    maxItems: z
-        .number()
-        .min(1)
-        .optional()
-        .describe("Maximum total items to return across all pages"),
-    cursor: z.string().optional().describe("Cursor to start from"),
-})
-    .describe("List tables available to the authenticated user");

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

@@ -1,10 +0,0 @@
-/**
- * Method-meta defaults shared across every plugin in the `tables/` domain.
- * Each plugin spreads `...tablesDefaults` into its `createPluginMethod` /
- * `createPaginatedPluginMethod` config so we declare `categories: ["table"]`
- * once instead of 12 times.
- */
-export declare const tablesDefaults: {
-    categories: string[];
-};
-//# sourceMappingURL=shared.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../src/plugins/tables/shared.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,eAAO,MAAM,cAAc;;CAEI,CAAC"}

package/dist/plugins/tables/shared.js

@@ -1,9 +0,0 @@
-/**
- * Method-meta defaults shared across every plugin in the `tables/` domain.
- * Each plugin spreads `...tablesDefaults` into its `createPluginMethod` /
- * `createPaginatedPluginMethod` config so we declare `categories: ["table"]`
- * once instead of 12 times.
- */
-export const tablesDefaults = {
-    categories: ["table"],
-};