@zapier/zapier-sdk 0.0.3 → 0.1.0

package/dist/functions/listApps/schemas.d.ts

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import type { Integration } from "../../types/domain";
+export declare const ListAppsSchema: z.ZodObject<{
+    category: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    offset: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    category?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}, {
+    category?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}>;
+export type ListAppsOptions = z.infer<typeof ListAppsSchema> & {
+    /** Base URL for Zapier API */
+    baseUrl?: string;
+    /** Authentication token */
+    token?: string;
+    /** Optional pre-instantiated API client */
+    api?: any;
+    /** Enable debug logging */
+    debug?: boolean;
+    /** Custom fetch implementation */
+    fetch?: typeof globalThis.fetch;
+};
+export interface ListAppsSdkFunction {
+    listApps: (options?: Partial<ListAppsOptions>) => Promise<Integration[]>;
+}

package/dist/functions/listApps/schemas.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListAppsSchema = void 0;
+const zod_1 = require("zod");
+const properties_1 = require("../../types/properties");
+const schema_utils_1 = require("../../schema-utils");
+const App_1 = require("../../schemas/App");
+// Pure Zod schema - no resolver metadata!
+exports.ListAppsSchema = (0, schema_utils_1.withOutputSchema)(zod_1.z
+    .object({
+    category: zod_1.z.string().optional().describe("Filter apps by category"),
+    limit: properties_1.LimitPropertySchema.optional().describe("Maximum number of items to return (1-200)"),
+    offset: properties_1.OffsetPropertySchema.optional().describe("Number of items to skip for pagination"),
+})
+    .describe("List all available apps with optional filtering"), App_1.AppItemSchema);

package/dist/functions/{listAuths.d.ts → listAuths/index.d.ts}

@@ -1,11 +1,5 @@
-import type { Authentication, FunctionConfig } from "../types";
-export interface ListAuthsOptions extends FunctionConfig {
-    appKey?: string;
-    account_id?: string;
-    owner?: string;
-    limit?: number;
-    offset?: number;
-}
+import type { Authentication } from "../../types/domain";
+import type { ListAuthsOptions } from "./schemas";
 /**
  * List available authentications with optional filtering
  *
@@ -15,4 +9,4 @@ export interface ListAuthsOptions extends FunctionConfig {
  * @param options - Filtering, pagination, and API configuration options
  * @returns Promise<Authentication[]> with pagination metadata
  */
-export declare function listAuths(options?: ListAuthsOptions): Promise<Authentication[]>;
+export declare function listAuths(options?: Partial<ListAuthsOptions>): Promise<Authentication[]>;

package/dist/functions/{listAuths.js → listAuths/index.js}

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.listAuths = listAuths;
-const api_1 = require("../api");
-const getApp_1 = require("./getApp");
+const api_1 = require("../../api");
+const getApp_1 = require("../getApp");
 /**
  * List available authentications with optional filtering
  *
@@ -27,7 +27,7 @@ async function listAuths(options = {}) {
             try {
                 // Use the standalone getApp function
                 const app = await (0, getApp_1.getApp)({
-                    key: options.appKey,
+                    appKey: options.appKey,
                     api,
                     token: options.token,
                     baseUrl: options.baseUrl,
@@ -107,8 +107,8 @@ async function listAuths(options = {}) {
             owner: undefined,
         });
         // Filter out auths the user already owns to avoid duplicates
-        const ownedAuthIds = new Set(ownedAuths.map((auth) => auth.id));
-        const additionalAuths = allAuths.filter((auth) => !ownedAuthIds.has(auth.id));
+        const ownedAuthenticationIds = new Set(ownedAuths.map((auth) => auth.id));
+        const additionalAuths = allAuths.filter((auth) => !ownedAuthenticationIds.has(auth.id));
         // Combine and slice to the requested limit
         const combined = [...ownedAuths, ...additionalAuths];
         return combined.slice(0, options.limit);

package/dist/functions/listAuths/info.d.ts

@@ -0,0 +1,24 @@
+import { listAuths } from "./index";
+export declare const listAuthsInfo: {
+    name: string;
+    inputSchema: import("zod").ZodObject<{
+        appKey: import("zod").ZodOptional<import("zod").ZodString>;
+        account_id: import("zod").ZodOptional<import("zod").ZodString>;
+        owner: import("zod").ZodOptional<import("zod").ZodString>;
+        limit: import("zod").ZodOptional<import("zod").ZodDefault<import("zod").ZodNumber>>;
+        offset: import("zod").ZodOptional<import("zod").ZodDefault<import("zod").ZodNumber>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        appKey?: string | undefined;
+        account_id?: string | undefined;
+        owner?: string | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+    }, {
+        appKey?: string | undefined;
+        account_id?: string | undefined;
+        owner?: string | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+    }>;
+    implementation: typeof listAuths;
+};

package/dist/functions/listAuths/info.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listAuthsInfo = void 0;
+const index_1 = require("./index");
+const schemas_1 = require("./schemas");
+// Function registry info - imports both function and schema
+exports.listAuthsInfo = {
+    name: index_1.listAuths.name,
+    inputSchema: schemas_1.ListAuthsSchema,
+    implementation: index_1.listAuths,
+};

package/dist/functions/listAuths/schemas.d.ts

@@ -0,0 +1,36 @@
+import { z } from "zod";
+import type { Authentication } from "../../types/domain";
+export declare const ListAuthsSchema: z.ZodObject<{
+    appKey: z.ZodOptional<z.ZodString>;
+    account_id: z.ZodOptional<z.ZodString>;
+    owner: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    offset: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    appKey?: string | undefined;
+    account_id?: string | undefined;
+    owner?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}, {
+    appKey?: string | undefined;
+    account_id?: string | undefined;
+    owner?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}>;
+export type ListAuthsOptions = z.infer<typeof ListAuthsSchema> & {
+    /** Base URL for Zapier API */
+    baseUrl?: string;
+    /** Authentication token */
+    token?: string;
+    /** Optional pre-instantiated API client */
+    api?: any;
+    /** Enable debug logging */
+    debug?: boolean;
+    /** Custom fetch implementation */
+    fetch?: typeof globalThis.fetch;
+};
+export interface ListAuthsSdkFunction {
+    listAuths: (options?: Partial<ListAuthsOptions>) => Promise<Authentication[]>;
+}

package/dist/functions/listAuths/schemas.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListAuthsSchema = void 0;
+const zod_1 = require("zod");
+const properties_1 = require("../../types/properties");
+const schema_utils_1 = require("../../schema-utils");
+const Auth_1 = require("../../schemas/Auth");
+// Pure Zod schema - no resolver metadata!
+exports.ListAuthsSchema = (0, schema_utils_1.withOutputSchema)(zod_1.z
+    .object({
+    appKey: properties_1.AppKeyPropertySchema.optional().describe("App slug to get authentications for (e.g., 'slack', 'github')"),
+    account_id: zod_1.z.string().optional().describe("Filter by account ID"),
+    owner: zod_1.z.string().optional().describe("Filter by owner"),
+    limit: properties_1.LimitPropertySchema.optional().describe("Maximum number of items to return (1-200)"),
+    offset: properties_1.OffsetPropertySchema.optional().describe("Number of items to skip for pagination"),
+})
+    .describe("List available authentications with optional filtering"), Auth_1.AuthItemSchema);

package/dist/functions/{listFields.d.ts → listFields/index.d.ts}

@@ -1,18 +1,12 @@
-import type { ActionField, FunctionConfig } from "../types";
-export interface ListFieldsOptions extends FunctionConfig {
-    app: string;
-    action: string;
-    type: string;
-    authId?: number;
-    params?: Record<string, any>;
-}
+import type { ActionField } from "../../types/domain";
+import type { ListFieldsOptions } from "./schemas";
 /**
  * List available fields for an action
  *
  * This function can be used standalone without instantiating a full SDK,
  * which enables better tree-shaking in applications that only need this functionality.
  *
- * @param options - Action details, auth ID, params, and API configuration options
+ * @param options - Action details, authentication ID, params, and API configuration options
  * @returns Promise<ActionField[]>
  */
 export declare function listFields(options: ListFieldsOptions): Promise<ActionField[]>;

package/dist/functions/{listFields.js → listFields/index.js}

@@ -1,27 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.listFields = listFields;
-const api_1 = require("../api");
-const getApp_1 = require("./getApp");
+const api_1 = require("../../api");
+const getApp_1 = require("../getApp");
 /**
  * List available fields for an action
  *
  * This function can be used standalone without instantiating a full SDK,
  * which enables better tree-shaking in applications that only need this functionality.
  *
- * @param options - Action details, auth ID, params, and API configuration options
+ * @param options - Action details, authentication ID, params, and API configuration options
  * @returns Promise<ActionField[]>
  */
 async function listFields(options) {
     const api = (0, api_1.getOrCreateApiClient)(options);
-    // Map consistent parameter names to internal API names
-    const { app, action, type, authId, params } = options;
-    const appKey = app;
-    const actionKey = action;
-    const actionType = type;
+    // Extract parameters
+    const { appKey, actionKey, actionType, authenticationId, params } = options;
     // Use the standalone getApp function
     const appData = await (0, getApp_1.getApp)({
-        key: appKey,
+        appKey,
         api,
         token: options.token,
         baseUrl: options.baseUrl,
@@ -37,7 +34,7 @@ async function listFields(options) {
         selected_api: selectedApi,
         action: actionKey,
         type_of: actionType,
-        authentication_id: authId,
+        authentication_id: authenticationId,
         params: params || {},
     };
     const needsData = await api.post("/api/v4/implementations/needs/", needsRequest);
@@ -65,3 +62,4 @@ async function listFields(options) {
         inputFormat: need.input_format,
     }));
 }
+// No registry info here - moved to info.ts for proper tree-shaking

package/dist/functions/listFields/info.d.ts

@@ -0,0 +1,24 @@
+import { listFields } from "./index";
+export declare const listFieldsInfo: {
+    name: string;
+    inputSchema: import("zod").ZodObject<{
+        appKey: import("zod").ZodString;
+        actionType: import("zod").ZodEnum<["read", "write", "search", "create", "update", "delete"]>;
+        actionKey: import("zod").ZodString;
+        authenticationId: import("zod").ZodOptional<import("zod").ZodNumber>;
+        params: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        appKey: string;
+        actionType: "create" | "update" | "search" | "delete" | "read" | "write";
+        actionKey: string;
+        params?: Record<string, any> | undefined;
+        authenticationId?: number | undefined;
+    }, {
+        appKey: string;
+        actionType: "create" | "update" | "search" | "delete" | "read" | "write";
+        actionKey: string;
+        params?: Record<string, any> | undefined;
+        authenticationId?: number | undefined;
+    }>;
+    implementation: typeof listFields;
+};

package/dist/functions/listFields/info.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listFieldsInfo = void 0;
+const index_1 = require("./index");
+const schemas_1 = require("./schemas");
+// Function registry info - imports both function and schema
+exports.listFieldsInfo = {
+    name: index_1.listFields.name,
+    inputSchema: schemas_1.ListFieldsSchema,
+    implementation: index_1.listFields,
+};

package/dist/functions/listFields/schemas.d.ts

@@ -0,0 +1,36 @@
+import { z } from "zod";
+import type { ActionField } from "../../types/domain";
+export declare const ListFieldsSchema: z.ZodObject<{
+    appKey: z.ZodString;
+    actionType: z.ZodEnum<["read", "write", "search", "create", "update", "delete"]>;
+    actionKey: z.ZodString;
+    authenticationId: z.ZodOptional<z.ZodNumber>;
+    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    appKey: string;
+    actionType: "create" | "update" | "search" | "delete" | "read" | "write";
+    actionKey: string;
+    params?: Record<string, any> | undefined;
+    authenticationId?: number | undefined;
+}, {
+    appKey: string;
+    actionType: "create" | "update" | "search" | "delete" | "read" | "write";
+    actionKey: string;
+    params?: Record<string, any> | undefined;
+    authenticationId?: number | undefined;
+}>;
+export type ListFieldsOptions = z.infer<typeof ListFieldsSchema> & {
+    /** Base URL for Zapier API */
+    baseUrl?: string;
+    /** Authentication token */
+    token?: string;
+    /** Optional pre-instantiated API client */
+    api?: any;
+    /** Enable debug logging */
+    debug?: boolean;
+    /** Custom fetch implementation */
+    fetch?: typeof globalThis.fetch;
+};
+export interface ListFieldsSdkFunction {
+    listFields: (options: ListFieldsOptions) => Promise<ActionField[]>;
+}

package/dist/functions/listFields/schemas.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListFieldsSchema = void 0;
+const zod_1 = require("zod");
+const properties_1 = require("../../types/properties");
+const schema_utils_1 = require("../../schema-utils");
+const Field_1 = require("../../schemas/Field");
+// Pure Zod schema - no resolver metadata!
+exports.ListFieldsSchema = (0, schema_utils_1.withOutputSchema)(zod_1.z
+    .object({
+    appKey: properties_1.AppKeyPropertySchema,
+    actionType: properties_1.ActionTypePropertySchema,
+    actionKey: properties_1.ActionKeyPropertySchema,
+    authenticationId: properties_1.AuthenticationIdPropertySchema.optional(),
+    params: properties_1.ParamsPropertySchema.optional().describe("Additional parameters that may affect available fields"),
+})
+    .describe("Get the input fields required for a specific action"), Field_1.FieldItemSchema);

package/dist/functions/{runAction.d.ts → runAction/index.d.ts}

@@ -1,11 +1,5 @@
-import type { ActionExecutionResult, FunctionConfig } from "../types";
-export interface RunActionOptions extends FunctionConfig {
-    app: string;
-    type: string;
-    action: string;
-    inputs?: Record<string, any>;
-    authId?: number;
-}
+import type { ActionExecutionResult } from "../../types/domain";
+import type { RunActionOptions } from "./schemas";
 /**
  * Execute an action
  *

package/dist/functions/{runAction.js → runAction/index.js}

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runAction = runAction;
-const api_1 = require("../api");
-const getAction_1 = require("./getAction");
-const getApp_1 = require("./getApp");
+const api_1 = require("../../api");
+const getAction_1 = require("../getAction");
+const getApp_1 = require("../getApp");
 /**
  * Execute an action
  *
@@ -14,7 +14,7 @@ const getApp_1 = require("./getApp");
  * @returns Promise<ActionExecutionResult>
  */
 async function runAction(options) {
-    const { app, type, action, inputs, authId: providedAuthId, token } = options;
+    const { appKey, actionType, actionKey, inputs, authenticationId: providedAuthenticationId, token, } = options;
     if (!token && !process.env.ZAPIER_TOKEN) {
         throw new Error("Authentication token is required to run actions. Please provide token in options or set ZAPIER_TOKEN environment variable.");
     }
@@ -22,24 +22,24 @@ async function runAction(options) {
     // Validate that the action exists
     const actionData = await (0, getAction_1.getAction)({
         ...options,
-        app: app,
-        action: action,
-        type: type,
+        appKey: appKey,
+        actionKey: actionKey,
+        actionType: actionType,
     });
     // Validate action type matches
-    if (actionData.type !== type) {
-        throw new Error(`Action type mismatch: expected ${type}, got ${actionData.type}`);
+    if (actionData.type !== actionType) {
+        throw new Error(`Action type mismatch: expected ${actionType}, got ${actionData.type}`);
     }
     // Execute the action using the appropriate API based on action type
     const startTime = Date.now();
     const result = await executeActionWithStrategy({
         api,
-        appSlug: app,
-        actionKey: action,
+        appSlug: appKey,
+        actionKey: actionKey,
         actionType: actionData.type,
         executionOptions: { inputs: inputs || {} },
         auth: token
-            ? { token: token, authentication_id: providedAuthId }
+            ? { token: token, authentication_id: providedAuthenticationId }
             : undefined,
         options,
     });
@@ -86,7 +86,7 @@ async function executeActionViaActionsApi(apiOptions) {
     const { api, appSlug, actionKey, actionType, executionOptions, auth, options, } = apiOptions;
     // Use the standalone getApp function
     const appData = await (0, getApp_1.getApp)({
-        key: appSlug,
+        appKey: appSlug,
         api,
         token: options.token,
         baseUrl: options.baseUrl,
@@ -123,7 +123,7 @@ async function executeActionViaInvokeApi(apiOptions) {
     const { api, appSlug, actionKey, actionType, executionOptions, auth, options, } = apiOptions;
     // Use the standalone getApp function
     const appData = await (0, getApp_1.getApp)({
-        key: appSlug,
+        appKey: appSlug,
         api,
         token: options.token,
         baseUrl: options.baseUrl,
@@ -154,3 +154,4 @@ async function executeActionViaInvokeApi(apiOptions) {
         resultExtractor: (result) => result.results || result,
     });
 }
+// No registry info here - moved to info.ts for proper tree-shaking

package/dist/functions/runAction/info.d.ts

@@ -0,0 +1,24 @@
+import { runAction } from "./index";
+export declare const runActionInfo: {
+    name: string;
+    inputSchema: import("zod").ZodObject<{
+        appKey: import("zod").ZodString;
+        actionType: import("zod").ZodEnum<["read", "write", "search", "create", "update", "delete"]>;
+        actionKey: import("zod").ZodString;
+        inputs: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
+        authenticationId: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, "strip", import("zod").ZodTypeAny, {
+        appKey: string;
+        actionType: "create" | "update" | "search" | "delete" | "read" | "write";
+        actionKey: string;
+        inputs?: Record<string, any> | undefined;
+        authenticationId?: number | undefined;
+    }, {
+        appKey: string;
+        actionType: "create" | "update" | "search" | "delete" | "read" | "write";
+        actionKey: string;
+        inputs?: Record<string, any> | undefined;
+        authenticationId?: number | undefined;
+    }>;
+    implementation: typeof runAction;
+};

package/dist/functions/runAction/info.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runActionInfo = void 0;
+const index_1 = require("./index");
+const schemas_1 = require("./schemas");
+// Function registry info - imports both function and schema
+exports.runActionInfo = {
+    name: index_1.runAction.name,
+    inputSchema: schemas_1.RunActionSchema,
+    implementation: index_1.runAction,
+};

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

@@ -0,0 +1,36 @@
+import { z } from "zod";
+import type { ActionExecutionResult } from "../../types/domain";
+export declare const RunActionSchema: z.ZodObject<{
+    appKey: z.ZodString;
+    actionType: z.ZodEnum<["read", "write", "search", "create", "update", "delete"]>;
+    actionKey: z.ZodString;
+    inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    authenticationId: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    appKey: string;
+    actionType: "create" | "update" | "search" | "delete" | "read" | "write";
+    actionKey: string;
+    inputs?: Record<string, any> | undefined;
+    authenticationId?: number | undefined;
+}, {
+    appKey: string;
+    actionType: "create" | "update" | "search" | "delete" | "read" | "write";
+    actionKey: string;
+    inputs?: Record<string, any> | undefined;
+    authenticationId?: number | undefined;
+}>;
+export type RunActionOptions = z.infer<typeof RunActionSchema> & {
+    /** Base URL for Zapier API */
+    baseUrl?: string;
+    /** Authentication token */
+    token?: string;
+    /** Optional pre-instantiated API client */
+    api?: any;
+    /** Enable debug logging */
+    debug?: boolean;
+    /** Custom fetch implementation */
+    fetch?: typeof globalThis.fetch;
+};
+export interface RunActionSdkFunction {
+    runAction: (options: RunActionOptions) => Promise<ActionExecutionResult>;
+}

package/dist/functions/runAction/schemas.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunActionSchema = void 0;
+const zod_1 = require("zod");
+const properties_1 = require("../../types/properties");
+// Pure Zod schema - no resolver metadata!
+exports.RunActionSchema = zod_1.z
+    .object({
+    appKey: properties_1.AppKeyPropertySchema,
+    actionType: properties_1.ActionTypePropertySchema,
+    actionKey: properties_1.ActionKeyPropertySchema,
+    inputs: properties_1.InputsPropertySchema.optional().describe("Input parameters for the action"),
+    authenticationId: properties_1.AuthenticationIdPropertySchema.optional(),
+})
+    .describe("Execute an action with the given inputs");

package/dist/index.d.ts

@@ -1,5 +1,7 @@
-export * from "./types";
-export * from "./actions-sdk";
+export * from "./types/domain";
+export * from "./types/properties";
+export * from "./plugins/apps";
+export * from "./resolvers";
 export { listAuths } from "./functions/listAuths";
 export { listApps } from "./functions/listApps";
 export { getApp } from "./functions/getApp";
@@ -9,4 +11,5 @@ export { runAction } from "./functions/runAction";
 export { listFields } from "./functions/listFields";
 export { generateTypes } from "./functions/generateTypes";
 export { bundleCode } from "./functions/bundleCode";
-export { createZapierSdk, ZapierSdk, ZapierSdkOptions } from "./sdk";
+export { createZapierSdk, ZapierSdkOptions } from "./sdk";
+export type { ZapierSdk } from "./types/sdk";

package/dist/index.js

@@ -15,9 +15,13 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createZapierSdk = exports.bundleCode = exports.generateTypes = exports.listFields = exports.runAction = exports.getAction = exports.listActions = exports.getApp = exports.listApps = exports.listAuths = void 0;
-// Export everything from types and actions-sdk
-__exportStar(require("./types"), exports);
-__exportStar(require("./actions-sdk"), exports);
+// Export everything from types and plugins
+__exportStar(require("./types/domain"), exports);
+__exportStar(require("./types/properties"), exports);
+__exportStar(require("./plugins/apps"), exports);
+// Export resolvers for CLI use
+__exportStar(require("./resolvers"), exports);
+// Note: SdkSchemas is now available via SDK.__registry
 // Export individual functions for tree-shaking
 var listAuths_1 = require("./functions/listAuths");
 Object.defineProperty(exports, "listAuths", { enumerable: true, get: function () { return listAuths_1.listAuths; } });

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

@@ -0,0 +1,8 @@
+import { type ApiClient } from "../../api";
+import type { ActionProxy } from "./types";
+export interface AppsPluginOptions {
+    api: ApiClient;
+    token?: string;
+}
+export declare function createAppsPlugin(options: AppsPluginOptions): ActionProxy;
+export type { ActionProxy, AppsPluginSdkExtension } from "./types";