@zapier/zapier-sdk 0.77.0 → 0.77.2

package/dist/plugins/runAction/schemas.d.ts

@@ -1,108 +0,0 @@
-import { z } from "zod";
-export declare const RunActionSchema: z.ZodObject<{
-    app: z.ZodString & {
-        _def: z.core.$ZodStringDef & import("kitcore").PositionalMetadata;
-    };
-    actionType: z.ZodEnum<{
-        filter: "filter";
-        write: "write";
-        read: "read";
-        read_bulk: "read_bulk";
-        run: "run";
-        search: "search";
-        search_and_write: "search_and_write";
-        search_or_write: "search_or_write";
-    }>;
-    action: z.ZodString & {
-        _def: z.core.$ZodStringDef & import("kitcore").PositionalMetadata;
-    };
-    connection: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-    connectionId: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
-    authenticationId: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
-    inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    timeoutMs: z.ZodOptional<z.ZodNumber>;
-    pageSize: z.ZodOptional<z.ZodNumber>;
-    maxItems: z.ZodOptional<z.ZodNumber>;
-    cursor: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-declare const RunActionSchemaDeprecated: z.ZodObject<{
-    appKey: z.ZodString & {
-        _def: z.core.$ZodStringDef & import("kitcore").PositionalMetadata;
-    };
-    actionType: z.ZodEnum<{
-        filter: "filter";
-        write: "write";
-        read: "read";
-        read_bulk: "read_bulk";
-        run: "run";
-        search: "search";
-        search_and_write: "search_and_write";
-        search_or_write: "search_or_write";
-    }>;
-    actionKey: z.ZodString;
-    connection: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-    connectionId: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
-    authenticationId: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
-    inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    timeoutMs: z.ZodOptional<z.ZodNumber>;
-    pageSize: z.ZodOptional<z.ZodNumber>;
-    maxItems: z.ZodOptional<z.ZodNumber>;
-    cursor: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export declare const RunActionInputSchema: z.ZodUnion<readonly [z.ZodObject<{
-    app: z.ZodString & {
-        _def: z.core.$ZodStringDef & import("kitcore").PositionalMetadata;
-    };
-    actionType: z.ZodEnum<{
-        filter: "filter";
-        write: "write";
-        read: "read";
-        read_bulk: "read_bulk";
-        run: "run";
-        search: "search";
-        search_and_write: "search_and_write";
-        search_or_write: "search_or_write";
-    }>;
-    action: z.ZodString & {
-        _def: z.core.$ZodStringDef & import("kitcore").PositionalMetadata;
-    };
-    connection: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-    connectionId: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
-    authenticationId: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
-    inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    timeoutMs: z.ZodOptional<z.ZodNumber>;
-    pageSize: z.ZodOptional<z.ZodNumber>;
-    maxItems: z.ZodOptional<z.ZodNumber>;
-    cursor: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    appKey: z.ZodString & {
-        _def: z.core.$ZodStringDef & import("kitcore").PositionalMetadata;
-    };
-    actionType: z.ZodEnum<{
-        filter: "filter";
-        write: "write";
-        read: "read";
-        read_bulk: "read_bulk";
-        run: "run";
-        search: "search";
-        search_and_write: "search_and_write";
-        search_or_write: "search_or_write";
-    }>;
-    actionKey: z.ZodString;
-    connection: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-    connectionId: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
-    authenticationId: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
-    inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    timeoutMs: z.ZodOptional<z.ZodNumber>;
-    pageSize: z.ZodOptional<z.ZodNumber>;
-    maxItems: z.ZodOptional<z.ZodNumber>;
-    cursor: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>]>;
-export type RunActionOptions = z.infer<typeof RunActionSchema> | (Omit<z.infer<typeof RunActionSchemaDeprecated>, "appKey" | "actionKey"> & {
-    /** @deprecated Use `app` instead. */
-    appKey: z.infer<typeof RunActionSchemaDeprecated>["appKey"];
-    /** @deprecated Use `action` instead. */
-    actionKey: z.infer<typeof RunActionSchemaDeprecated>["actionKey"];
-});
-export {};
-//# sourceMappingURL=schemas.d.ts.map

package/dist/plugins/runAction/schemas.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/plugins/runAction/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA6CxB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;iBAexB,CAAC;AAGL,QAAA,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;iBAMF,CAAC;AAG9B,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAEA,CAAC;AAGlC,MAAM,MAAM,gBAAgB,GACxB,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,GAC/B,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,EAAE,QAAQ,GAAG,WAAW,CAAC,GAAG;IACzE,qCAAqC;IACrC,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC,QAAQ,CAAC,CAAC;IAC5D,wCAAwC;IACxC,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC,WAAW,CAAC,CAAC;CACnE,CAAC,CAAC"}

package/dist/plugins/runAction/schemas.js

@@ -1,53 +0,0 @@
-import { z } from "zod";
-import { AppKeyPropertySchema, AppPropertySchema, ActionTypePropertySchema, ActionKeyPropertySchema, ActionPropertySchema, ConnectionIdPropertySchema, ConnectionPropertySchema, AuthenticationIdPropertySchema, InputsPropertySchema, ActionTimeoutMsPropertySchema, } from "../../types/properties";
-const RunActionDescription = "Execute an action with the given inputs";
-// Base schema for shared properties
-const RunActionBaseSchema = z.object({
-    connection: ConnectionPropertySchema.optional().describe("Connection alias or connection ID (UUID or positive integer). Strings that match a key in the connections map are resolved against it; otherwise the value is used as a connection ID directly. Mutually exclusive with connectionId."),
-    connectionId: ConnectionIdPropertySchema.nullable()
-        .optional()
-        .describe("Connection ID to use when running the action. Required if the action needs a connection to authenticate and interact with the service.")
-        .meta({ deprecated: true }),
-    /** @deprecated Use connection instead */
-    authenticationId: AuthenticationIdPropertySchema.nullable()
-        .optional()
-        .meta({ deprecated: true }),
-    inputs: InputsPropertySchema.optional().describe("Input parameters for the action"),
-    timeoutMs: ActionTimeoutMsPropertySchema,
-    pageSize: z.number().min(1).optional().describe("Number of results 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"),
-});
-// Schema for docs/registry (new param names only)
-export const RunActionSchema = z
-    .object({
-    app: AppPropertySchema,
-    actionType: ActionTypePropertySchema,
-    action: ActionPropertySchema,
-})
-    .merge(RunActionBaseSchema)
-    .describe(RunActionDescription)
-    .meta({
-    aliases: {
-        appKey: "app",
-        actionKey: "action",
-        connectionId: "connection",
-        authenticationId: "connection",
-    },
-});
-// Deprecated schema (backward compat)
-const RunActionSchemaDeprecated = z
-    .object({
-    appKey: AppKeyPropertySchema,
-    actionType: ActionTypePropertySchema,
-    actionKey: ActionKeyPropertySchema,
-})
-    .merge(RunActionBaseSchema);
-// Union for runtime validation (accepts either new or old names)
-export const RunActionInputSchema = z
-    .union([RunActionSchema, RunActionSchemaDeprecated])
-    .describe(RunActionDescription);

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

@@ -1,48 +0,0 @@
-export declare const createTablePlugin: (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: {
-        meta: Record<string, import("kitcore").PluginMeta>;
-    };
-}) => {
-    createTable: (options?: {
-        name: string;
-        description?: string | undefined;
-    } | undefined) => Promise<{
-        data: {
-            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: {
-            createTable: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-};
-export type CreateTablePluginProvides = ReturnType<typeof createTablePlugin>;
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/createTable/index.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoB7B,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

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

@@ -1,20 +0,0 @@
-import { definePlugin } from "kitcore";
-import { createPluginMethod } from "kitcore";
-import { CreateTableOptionsSchema, CreateTableApiResponseSchema, TableItemSchema, } from "./schemas";
-import { tableNameResolver } from "../../../resolvers";
-import { transformTableItem } from "../utils";
-import { tablesDefaults } from "../shared";
-export const createTablePlugin = definePlugin((sdk) => createPluginMethod(sdk, {
-    ...tablesDefaults,
-    name: "createTable",
-    type: "create",
-    itemType: "Table",
-    inputSchema: CreateTableOptionsSchema,
-    outputSchema: TableItemSchema,
-    resolvers: { name: tableNameResolver },
-    handler: async ({ sdk, options }) => {
-        const rawResponse = await sdk.context.api.post("/tables/api/v1/tables", { name: options.name, description: options.description }, { authRequired: true });
-        const response = CreateTableApiResponseSchema.parse(rawResponse);
-        return { data: transformTableItem(response.data) };
-    },
-}));

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

@@ -1,36 +0,0 @@
-import { z } from "zod";
-import { TableItemSchema, TableApiItemSchema, type TableItem, type TableApiItem } from "../listTables/schemas";
-export { TableItemSchema, TableApiItemSchema };
-export type { TableItem, TableApiItem };
-export declare const CreateTableApiResponseSchema: z.ZodObject<{
-    data: 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>;
-}, z.core.$strip>;
-export type CreateTableApiResponse = z.infer<typeof CreateTableApiResponseSchema>;
-export declare const CreateTableOptionsSchema: z.ZodObject<{
-    name: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export type CreateTableOptions = z.infer<typeof CreateTableOptionsSchema>;
-export interface CreateTableResult {
-    data: TableItem;
-}
-export interface CreateTableSdkFunction {
-    createTable: (options: CreateTableOptions) => Promise<CreateTableResult>;
-}
-//# sourceMappingURL=schemas.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/createTable/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EACL,eAAe,EACf,kBAAkB,EAClB,KAAK,SAAS,EACd,KAAK,YAAY,EAClB,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EAAE,eAAe,EAAE,kBAAkB,EAAE,CAAC;AAC/C,YAAY,EAAE,SAAS,EAAE,YAAY,EAAE,CAAC;AAExC,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;iBAEvC,CAAC;AAEH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAC1C,OAAO,4BAA4B,CACpC,CAAC;AAEF,eAAO,MAAM,wBAAwB;;;iBAQJ,CAAC;AAElC,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAG1E,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,SAAS,CAAC;CACjB;AAGD,MAAM,WAAW,sBAAsB;IACrC,WAAW,EAAE,CAAC,OAAO,EAAE,kBAAkB,KAAK,OAAO,CAAC,iBAAiB,CAAC,CAAC;CAC1E"}

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

@@ -1,16 +0,0 @@
-import { z } from "zod";
-import { TableItemSchema, TableApiItemSchema, } from "../listTables/schemas";
-// Re-export for consumers
-export { TableItemSchema, TableApiItemSchema };
-export const CreateTableApiResponseSchema = z.object({
-    data: TableApiItemSchema,
-});
-export const CreateTableOptionsSchema = z
-    .object({
-    name: z.string().min(1).describe("The name for the new table"),
-    description: z
-        .string()
-        .optional()
-        .describe("An optional description of the table"),
-})
-    .describe("Create a new table");

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

@@ -1,92 +0,0 @@
-export declare const createTableFieldsPlugin: (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>;
-        };
-    };
-} & {
-    context: {
-        meta: Record<string, import("kitcore").PluginMeta>;
-    };
-}) => {
-    createTableFields: (options?: {
-        table: string;
-        fields: {
-            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;
-            options?: Record<string, unknown> | undefined;
-            config?: Record<string, unknown> | undefined;
-        }[];
-    } | {
-        tableId: string;
-        fields: {
-            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;
-            options?: Record<string, unknown> | undefined;
-            config?: Record<string, unknown> | 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: {
-            createTableFields: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-};
-export type CreateTableFieldsPluginProvides = ReturnType<typeof createTableFieldsPlugin>;
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/createTableFields/index.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8BnC,CAAC;AAEF,MAAM,MAAM,+BAA+B,GAAG,UAAU,CACtD,OAAO,uBAAuB,CAC/B,CAAC"}

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

@@ -1,29 +0,0 @@
-import { definePlugin } from "kitcore";
-import { createPluginMethod } from "kitcore";
-import { CreateTableFieldsOptionsInputSchema, CreateTableFieldsApiResponseSchema, FieldItemSchema, } from "./schemas";
-import { tableFieldItemFormatter } from "../../../formatters/tableField";
-import { tableIdResolver, tableFieldsResolver } from "../../../resolvers";
-import { transformFieldItem } from "../utils";
-import { tablesDefaults } from "../shared";
-export const createTableFieldsPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
-    ...tablesDefaults,
-    name: "createTableFields",
-    type: "create",
-    itemType: "Field",
-    returnType: "FieldItem[]",
-    inputSchema: CreateTableFieldsOptionsInputSchema,
-    outputSchema: FieldItemSchema,
-    formatter: tableFieldItemFormatter,
-    resolvers: { table: tableIdResolver, fields: tableFieldsResolver },
-    handler: async ({ sdk, options }) => {
-        const tableId = "table" in options ? options.table : options.tableId;
-        const rawResponse = await sdk.context.api.post(`/tables/api/v1/tables/${tableId}/fields`, { new_fields: options.fields }, {
-            authRequired: true,
-            resource: { type: "table", id: tableId },
-        });
-        const response = CreateTableFieldsApiResponseSchema.parse(rawResponse);
-        return {
-            data: response.data.map((changeset) => transformFieldItem(changeset.new)),
-        };
-    },
-}));