@zapier/zapier-sdk 0.77.0 → 0.77.2

package/dist/plugins/getConnectionStartUrl/index.d.ts

@@ -1,206 +0,0 @@
-import { type GetConnectionStartUrlItem } from "./schemas";
-export declare const getConnectionStartUrlPlugin: (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: {
-        getResolvedManifest: () => Promise<import("../manifest").Manifest | null>;
-        getVersionedImplementationId: (appKey: string) => Promise<string | null>;
-        resolveAppKeys: ({ appKeys }: {
-            appKeys: string[];
-        }) => Promise<import("../..").ResolvedAppLocator[]>;
-        updateManifestEntry: (options: import("../manifest").UpdateManifestEntryOptions) => Promise<import("../manifest").UpdateManifestEntryResult>;
-        addActionEntry: (options: import("../manifest").AddActionEntryOptions) => Promise<import("../manifest").AddActionEntryResult>;
-        findActionEntry: ({ name, manifest, }: {
-            name: string;
-            manifest: import("../manifest").Manifest;
-        }) => import("../manifest").ActionEntry | null;
-        listActionEntries: ({ configPath, }?: {
-            configPath?: string;
-        }) => Promise<Array<[string, import("../manifest").ActionEntry]>>;
-        deleteActionEntry: ({ name, configPath, skipWrite, }: {
-            name: string;
-            configPath?: string;
-            skipWrite?: boolean;
-        }) => Promise<import("../manifest").Manifest>;
-        hasActionEntry: ({ name, manifest, }: {
-            name: string;
-            manifest: import("../manifest").Manifest;
-        }) => boolean;
-        findManifestEntry: typeof import("../manifest").findManifestEntry;
-        readManifestFromFile: typeof import("../manifest").readManifestFromFile;
-        getManifestConnections: () => Promise<Record<string, {
-            connectionId: string | number;
-        }> | null>;
-    };
-} & {
-    getApp: (options?: {
-        app: string;
-    } | {
-        appKey: string;
-    } | undefined) => Promise<{
-        data: {
-            slug: string;
-            title: string;
-            key: string;
-            implementation_id: string;
-            description?: string | undefined;
-            is_hidden?: boolean | undefined;
-            auth_type?: string | undefined;
-            actions?: {
-                read?: number | undefined;
-                read_bulk?: number | undefined;
-                write?: number | undefined;
-                search?: number | undefined;
-                search_or_write?: number | undefined;
-                search_and_write?: number | undefined;
-                filter?: number | undefined;
-            } | undefined;
-            is_deprecated?: boolean | undefined;
-            is_beta?: boolean | undefined;
-            is_premium?: boolean | undefined;
-            age_in_days?: number | undefined;
-            banner?: string | undefined;
-            categories?: {
-                id: number;
-                name: string;
-                slug: string;
-            }[] | undefined;
-            images?: {
-                url_16x16?: string | undefined;
-                url_32x32?: string | undefined;
-                url_64x64?: string | undefined;
-                url_128x128?: string | undefined;
-            } | undefined;
-            popularity?: number | undefined;
-            has_filters?: boolean | undefined;
-            has_reads?: boolean | undefined;
-            has_searches?: boolean | undefined;
-            has_searches_or_writes?: boolean | undefined;
-            has_upfront_fields?: boolean | undefined;
-            has_writes?: boolean | undefined;
-            is_built_in?: boolean | undefined;
-            is_featured?: boolean | undefined;
-            is_invite?: boolean | undefined;
-            is_public?: boolean | undefined;
-            is_upcoming?: boolean | undefined;
-            visibility?: string | undefined;
-            primary_color?: string | undefined;
-            secondary_color?: string | undefined;
-            classification?: string | undefined;
-            api_docs_url?: string | undefined;
-            image?: string | undefined;
-            version?: string | undefined;
-        };
-    }>;
-} & {
-    context: {
-        meta: {
-            getApp: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-} & {
-    listApps: (options?: ({
-        search?: string | undefined;
-        apps?: string[] | undefined;
-        appKeys?: string[] | undefined;
-        pageSize?: number | undefined;
-        maxItems?: number | undefined;
-        cursor?: string | undefined;
-    } & {
-        cursor?: string;
-        pageSize?: number;
-        maxItems?: number;
-    }) | undefined) => import("kitcore").PaginatedSdkResult<{
-        slug: string;
-        title: string;
-        key: string;
-        implementation_id: string;
-        description?: string | undefined;
-        is_hidden?: boolean | undefined;
-        auth_type?: string | undefined;
-        actions?: {
-            read?: number | undefined;
-            read_bulk?: number | undefined;
-            write?: number | undefined;
-            search?: number | undefined;
-            search_or_write?: number | undefined;
-            search_and_write?: number | undefined;
-            filter?: number | undefined;
-        } | undefined;
-        is_deprecated?: boolean | undefined;
-        is_beta?: boolean | undefined;
-        is_premium?: boolean | undefined;
-        age_in_days?: number | undefined;
-        banner?: string | undefined;
-        categories?: {
-            id: number;
-            name: string;
-            slug: string;
-        }[] | undefined;
-        images?: {
-            url_16x16?: string | undefined;
-            url_32x32?: string | undefined;
-            url_64x64?: string | undefined;
-            url_128x128?: string | undefined;
-        } | undefined;
-        popularity?: number | undefined;
-        has_filters?: boolean | undefined;
-        has_reads?: boolean | undefined;
-        has_searches?: boolean | undefined;
-        has_searches_or_writes?: boolean | undefined;
-        has_upfront_fields?: boolean | undefined;
-        has_writes?: boolean | undefined;
-        is_built_in?: boolean | undefined;
-        is_featured?: boolean | undefined;
-        is_invite?: boolean | undefined;
-        is_public?: boolean | undefined;
-        is_upcoming?: boolean | undefined;
-        visibility?: string | undefined;
-        primary_color?: string | undefined;
-        secondary_color?: string | undefined;
-        classification?: string | undefined;
-        api_docs_url?: string | undefined;
-        image?: string | undefined;
-        version?: string | undefined;
-    }>;
-} & {
-    context: {
-        meta: {
-            listApps: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-} & {
-    context: import("../eventEmission").EventEmissionContext;
-} & {
-    context: {
-        meta: Record<string, import("kitcore").PluginMeta>;
-    };
-}) => {
-    getConnectionStartUrl: (options?: {
-        app: string;
-    } | undefined) => Promise<{
-        data: GetConnectionStartUrlItem;
-    }>;
-} & {
-    context: {
-        meta: {
-            getConnectionStartUrl: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-};
-export type GetConnectionStartUrlPluginProvides = ReturnType<typeof getConnectionStartUrlPlugin>;
-//# sourceMappingURL=index.d.ts.map

package/dist/plugins/getConnectionStartUrl/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/getConnectionStartUrl/index.ts"],"names":[],"mappings":"AAQA,OAAO,EAGL,KAAK,yBAAyB,EAC/B,MAAM,WAAW,CAAC;AAoBnB,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAmDuhX,CAAC;;;;sBAAiX,CAAC;qBAAyB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cApCp7X,yBAAyB;;;;;;;;CA+BhD,CAAC;AAEF,MAAM,MAAM,mCAAmC,GAAG,UAAU,CAC1D,OAAO,2BAA2B,CACnC,CAAC"}

package/dist/plugins/getConnectionStartUrl/index.js

@@ -1,39 +0,0 @@
-import { definePlugin, createPluginMethod } from "kitcore";
-import { setMethodMetadata } from "../eventEmission/method-metadata";
-import { appKeyResolver } from "../../resolvers";
-import { GetConnectionStartUrlSchema, GetConnectionStartUrlItemSchema, } from "./schemas";
-// Server endpoint that mints a signed, single-use connection start URL.
-const START_PATH = "/zapier/api/authentications/v1/sdk/connections/start";
-export const getConnectionStartUrlPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
-    name: "getConnectionStartUrl",
-    categories: ["connection"],
-    type: "create",
-    itemType: "ConnectionStartUrl",
-    inputSchema: GetConnectionStartUrlSchema,
-    outputSchema: GetConnectionStartUrlItemSchema,
-    resolvers: { app: appKeyResolver },
-    handler: async ({ sdk: inner, options, }) => {
-        // Send the versionless app key: the server resolves it to the freshest
-        // production version when the user opens the URL, which can be minutes
-        // after this call.
-        const versionedKey = await inner.context.getVersionedImplementationId(options.app);
-        const selectedApi = versionedKey
-            ? versionedKey.split("@")[0]
-            : options.app;
-        // Tag this method's scope so eventEmission's onMethodEnd hook
-        // emits the MethodCalled event with `selected_api` set.
-        setMethodMetadata({ selectedApi });
-        const response = await inner.context.api.post(START_PATH, { selected_api: selectedApi }, { authRequired: true });
-        // Parse the mapped shape against the output schema so a server-side
-        // response change surfaces as a validation error here rather than
-        // silently producing a malformed item.
-        return {
-            data: GetConnectionStartUrlItemSchema.parse({
-                url: response.url,
-                expiresAt: response.expires_at,
-                startedAt: response.started_at,
-                app: selectedApi,
-            }),
-        };
-    },
-}));

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

@@ -1,15 +0,0 @@
-import { z } from "zod";
-export declare const GetConnectionStartUrlSchema: z.ZodObject<{
-    app: z.ZodString & {
-        _def: z.core.$ZodStringDef & import("kitcore").PositionalMetadata;
-    };
-}, z.core.$strip>;
-export type GetConnectionStartUrlOptions = z.infer<typeof GetConnectionStartUrlSchema>;
-export declare const GetConnectionStartUrlItemSchema: z.ZodObject<{
-    url: z.ZodString;
-    expiresAt: z.ZodNumber;
-    startedAt: z.ZodNumber;
-    app: z.ZodString;
-}, z.core.$strip>;
-export type GetConnectionStartUrlItem = z.infer<typeof GetConnectionStartUrlItemSchema>;
-//# sourceMappingURL=schemas.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/plugins/getConnectionStartUrl/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,2BAA2B;;;;iBAMrC,CAAC;AAEJ,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAChD,OAAO,2BAA2B,CACnC,CAAC;AAEF,eAAO,MAAM,+BAA+B;;;;;iBAyBzC,CAAC;AAEJ,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAC7C,OAAO,+BAA+B,CACvC,CAAC"}

package/dist/plugins/getConnectionStartUrl/schemas.js

@@ -1,23 +0,0 @@
-import { z } from "zod";
-import { AppPropertySchema } from "../../types/properties";
-export const GetConnectionStartUrlSchema = z
-    .object({
-    app: AppPropertySchema,
-})
-    .describe("Mint a short-lived URL that begins an SDK-initiated connection flow. The URL is signed by zapier.com and bound to the current user/account — opening it in a different browser session will fail the binding check. Returns the URL as data so the caller decides what to do with it.\n\nUse this directly (rather than the higher-level `create-connection`) when you want either of: (a) hand off the URL and *not* block waiting for completion — call this alone, skip `wait-for-new-connection` entirely, or (b) do something custom between minting the URL and waiting for the connection — call this, then email or DM the URL, render it as a QR code for mobile sign-in, etc., then call `wait-for-new-connection`. For the common case where you'd just print and poll back-to-back, `create-connection` is one call.\n\nPair with `wait-for-new-connection` to detect completion: pass the `startedAt` returned here straight through (it's the server's mint time, so polling isn't affected by client clock skew). Example (JS):\n\n```ts\nconst { data: { url, app, startedAt } } = await zapier.getConnectionStartUrl({ app: 'slack' });\n// hand `url` off — print it, DM it, email it, render a button, whatever\nconst { data: conn } = await zapier.waitForNewConnection({ app, startedAt });\n```");
-export const GetConnectionStartUrlItemSchema = z
-    .object({
-    url: z
-        .string()
-        .describe("URL the user should open in their browser to complete the auth flow. Single-use, time-limited."),
-    expiresAt: z
-        .number()
-        .describe("Unix timestamp (seconds) after which the URL's signature is rejected by zapier.com."),
-    startedAt: z
-        .number()
-        .describe("Unix timestamp (seconds) when the server minted the URL. Use it as the `startedAt` for `wait-for-new-connection` so polling is anchored to server time rather than a possibly-skewed client clock."),
-    app: z
-        .string()
-        .describe("Versionless app key the URL was minted for (e.g., 'SlackCLIAPI'). Useful for downstream filtering."),
-})
-    .describe("The signed start-URL plus metadata needed to poll for completion.");

package/dist/plugins/getProfile/index.d.ts

@@ -1,32 +0,0 @@
-import type { ApiClient } from "../../api/types";
-export declare const getProfilePlugin: (sdk: {
-    context: {
-        api: ApiClient;
-    };
-} & {
-    context: import("../eventEmission").EventEmissionContext;
-} & {
-    context: {
-        meta: Record<string, import("kitcore").PluginMeta>;
-    };
-}) => {
-    getProfile: (options?: Record<string, never> | undefined) => Promise<{
-        data: {
-            id: string;
-            first_name: string;
-            last_name: string;
-            full_name: string;
-            email: string;
-            email_confirmed: boolean;
-            timezone: string;
-        };
-    }>;
-} & {
-    context: {
-        meta: {
-            getProfile: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-};
-export type GetProfilePluginProvides = ReturnType<typeof getProfilePlugin>;
-//# sourceMappingURL=index.d.ts.map

package/dist/plugins/getProfile/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/getProfile/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAe,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAQ9D,eAAO,MAAM,gBAAgB;aAGd;QAAE,GAAG,EAAE,SAAS,CAAA;KAAE;;;;;;;;;;;;;;;;;;;;;;;;;CA6BhC,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

package/dist/plugins/getProfile/index.js

@@ -1,28 +0,0 @@
-import { definePlugin } from "kitcore";
-import { createPluginMethod } from "kitcore";
-import { GetProfileSchema } from "./schemas";
-import { UserProfileItemSchema } from "../../schemas/UserProfile";
-import { userProfileItemFormatter } from "../../formatters/userProfile";
-export const getProfilePlugin = definePlugin((sdk) => createPluginMethod(sdk, {
-    name: "getProfile",
-    categories: ["account"],
-    type: "item",
-    itemType: "Profile",
-    inputSchema: GetProfileSchema,
-    outputSchema: UserProfileItemSchema,
-    formatter: userProfileItemFormatter,
-    handler: async ({ sdk }) => {
-        const profile = await sdk.context.api.get("/zapier/api/v4/profile/", { authRequired: true });
-        return {
-            data: {
-                id: String(profile.public_id ?? profile.id),
-                first_name: profile.first_name,
-                last_name: profile.last_name,
-                full_name: `${profile.first_name} ${profile.last_name}`,
-                email: profile.email,
-                email_confirmed: profile.email_confirmed,
-                timezone: profile.timezone,
-            },
-        };
-    },
-}));

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

@@ -1,4 +0,0 @@
-import { z } from "zod";
-export declare const GetProfileSchema: z.ZodOptional<z.ZodObject<{}, z.core.$strip>>;
-export type GetProfileOptions = z.infer<typeof GetProfileSchema>;
-//# sourceMappingURL=schemas.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/plugins/getProfile/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,gBAAgB,+CAGwB,CAAC;AAEtD,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

package/dist/plugins/getProfile/schemas.js

@@ -1,5 +0,0 @@
-import { z } from "zod";
-export const GetProfileSchema = z
-    .object({})
-    .optional()
-    .describe("Get current user's profile information");