@zapier/zapier-sdk 0.0.3 → 0.1.1

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,6 +1,11 @@
-export * from "./types";
-export * from "./actions-sdk";
-export { listAuths } from "./functions/listAuths";
+export * from "./types/domain";
+export * from "./types/properties";
+export * from "./plugins/apps";
+export { isPositional } from "./schema-utils";
+export * from "./resolvers";
+export { listAuthentications } from "./functions/listAuthentications";
+export { findFirstAuthentication } from "./functions/findFirstAuthentication";
+export { findUniqueAuthentication } from "./functions/findUniqueAuthentication";
 export { listApps } from "./functions/listApps";
 export { getApp } from "./functions/getApp";
 export { listActions } from "./functions/listActions";
@@ -9,4 +14,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

@@ -14,13 +14,24 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 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);
+exports.createZapierSdk = exports.bundleCode = exports.generateTypes = exports.listFields = exports.runAction = exports.getAction = exports.listActions = exports.getApp = exports.listApps = exports.findUniqueAuthentication = exports.findFirstAuthentication = exports.listAuthentications = exports.isPositional = void 0;
+// Export everything from types and plugins
+__exportStar(require("./types/domain"), exports);
+__exportStar(require("./types/properties"), exports);
+__exportStar(require("./plugins/apps"), exports);
+// Export schema utilities for CLI
+var schema_utils_1 = require("./schema-utils");
+Object.defineProperty(exports, "isPositional", { enumerable: true, get: function () { return schema_utils_1.isPositional; } });
+// 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; } });
+var listAuthentications_1 = require("./functions/listAuthentications");
+Object.defineProperty(exports, "listAuthentications", { enumerable: true, get: function () { return listAuthentications_1.listAuthentications; } });
+var findFirstAuthentication_1 = require("./functions/findFirstAuthentication");
+Object.defineProperty(exports, "findFirstAuthentication", { enumerable: true, get: function () { return findFirstAuthentication_1.findFirstAuthentication; } });
+var findUniqueAuthentication_1 = require("./functions/findUniqueAuthentication");
+Object.defineProperty(exports, "findUniqueAuthentication", { enumerable: true, get: function () { return findUniqueAuthentication_1.findUniqueAuthentication; } });
 var listApps_1 = require("./functions/listApps");
 Object.defineProperty(exports, "listApps", { enumerable: true, get: function () { return listApps_1.listApps; } });
 var getApp_1 = require("./functions/getApp");

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";

package/dist/plugins/apps/index.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAppsPlugin = createAppsPlugin;
+const runAction_1 = require("../../functions/runAction");
+function createActionFunction(appKey, actionType, actionKey, options, pinnedAuthId) {
+    return async (actionOptions = {}) => {
+        const { api, token } = options;
+        const { inputs, authenticationId: providedAuthenticationId } = actionOptions;
+        // Use pinned auth ID first, then provided auth ID
+        const authenticationId = pinnedAuthId || providedAuthenticationId;
+        if (!authenticationId) {
+            throw new Error(`Authentication ID is required. Either use the factory pattern: sdk.apps.${appKey}({ authenticationId }) or provide authenticationId in the action call.`);
+        }
+        // Call runAction with the resolved parameters
+        return (0, runAction_1.runAction)({
+            appKey,
+            actionType: actionType,
+            actionKey,
+            inputs,
+            authenticationId,
+            api: api,
+            token,
+        });
+    };
+}
+function createActionTypeProxy(appKey, actionType, options, pinnedAuthId) {
+    return new Proxy({}, {
+        get(_, actionKey) {
+            if (typeof actionKey === "string") {
+                return createActionFunction(appKey, actionType, actionKey, options, pinnedAuthId);
+            }
+            return undefined;
+        },
+    });
+}
+function createPinnedAppProxy(appKey, options, pinnedAuthId) {
+    return new Proxy({}, {
+        get(_, actionType) {
+            if (typeof actionType === "string") {
+                return createActionTypeProxy(appKey, actionType, options, pinnedAuthId);
+            }
+            return undefined;
+        },
+    });
+}
+function createAppProxy(appKey, options) {
+    // Create the factory function that returns a pinned version
+    const appFactory = (factoryOptions) => {
+        return createPinnedAppProxy(appKey, options, factoryOptions.authenticationId);
+    };
+    // Add properties for direct usage (backward compatibility)
+    return new Proxy(appFactory, {
+        get(_, actionType) {
+            if (typeof actionType === "string") {
+                return createActionTypeProxy(appKey, actionType, options);
+            }
+            return undefined;
+        },
+    });
+}
+function createAppsProxy(options) {
+    // Create a proxy object that intercepts property access
+    const appsProxy = new Proxy({}, {
+        get(_, prop) {
+            if (typeof prop === "string") {
+                // First level: App names (e.g., 'slack')
+                return createAppProxy(prop, options);
+            }
+            return undefined;
+        },
+    });
+    return appsProxy;
+}
+// Export the plugin creation function
+function createAppsPlugin(options) {
+    return createAppsProxy(options);
+}

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

@@ -0,0 +1,6 @@
+import type { AppsPluginOptions } from "./index";
+export declare const appsPluginInfo: {
+    plugin: (_sdk: any, options: AppsPluginOptions) => {
+        apps: import("./types").ActionProxy;
+    };
+};

package/dist/plugins/apps/info.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appsPluginInfo = void 0;
+const index_1 = require("./index");
+// Plugin info object for registry (keeping for compatibility)
+exports.appsPluginInfo = {
+    plugin: (_sdk, options) => {
+        const appsProxy = (0, index_1.createAppsPlugin)(options);
+        return {
+            apps: appsProxy,
+        };
+    },
+};

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

@@ -0,0 +1,21 @@
+import type { ActionExecutionOptions, ActionExecutionResult } from "../../types/domain";
+interface AppFactoryOptions {
+    authenticationId: number;
+}
+interface ActionTypeProxy {
+    [action: string]: (options?: ActionExecutionOptions) => Promise<ActionExecutionResult>;
+}
+interface AppProxy {
+    [type: string]: ActionTypeProxy;
+}
+interface AppFactory {
+    (options: AppFactoryOptions): AppProxy;
+}
+type AppProxyWithFactory = AppFactory & AppProxy;
+export interface ActionProxy {
+    [app: string]: AppProxyWithFactory;
+}
+export interface AppsPluginSdkExtension {
+    apps: ActionProxy;
+}
+export {};

package/dist/plugins/apps/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/resolvers/actionKey.d.ts

@@ -0,0 +1,8 @@
+import type { ZapierSdk } from "../types/sdk";
+export interface ActionKeyResolver {
+    type: "dynamic";
+    depends: readonly string[];
+    fetch: (sdk: ZapierSdk, resolvedParams: Record<string, any>) => Promise<any[]>;
+    prompt: (items: any[], params: Record<string, any>) => any;
+}
+export declare const actionKeyResolver: ActionKeyResolver;

package/dist/resolvers/actionKey.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.actionKeyResolver = void 0;
+exports.actionKeyResolver = {
+    type: "dynamic",
+    depends: ["appKey", "actionType"],
+    fetch: async (sdk, resolvedParams) => {
+        const actions = await sdk.listActions({ appKey: resolvedParams.appKey });
+        return actions.filter((action) => action.type === resolvedParams.actionType);
+    },
+    prompt: (actions) => ({
+        type: "list",
+        name: "actionKey",
+        message: "Select action:",
+        choices: actions.map((action) => ({
+            name: `${action.name || action.key} - ${action.description || "No description"}`,
+            value: action.key,
+        })),
+    }),
+};

package/dist/resolvers/actionType.d.ts

@@ -0,0 +1,8 @@
+import type { ZapierSdk } from "../types/sdk";
+export interface ActionTypeResolver {
+    type: "dynamic";
+    depends: readonly string[];
+    fetch: (sdk: ZapierSdk, resolvedParams: Record<string, any>) => Promise<any[]>;
+    prompt: (items: any[], params: Record<string, any>) => any;
+}
+export declare const actionTypeResolver: ActionTypeResolver;

package/dist/resolvers/actionType.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.actionTypeResolver = void 0;
+exports.actionTypeResolver = {
+    type: "dynamic",
+    depends: ["appKey"],
+    fetch: async (sdk, resolvedParams) => {
+        const actions = await sdk.listActions({ appKey: resolvedParams.appKey });
+        const types = [...new Set(actions.map((action) => action.type))];
+        return types.map((type) => ({ key: type, name: type }));
+    },
+    prompt: (types) => ({
+        type: "list",
+        name: "actionType",
+        message: "Select action type:",
+        choices: types.map((type) => ({
+            name: type.name,
+            value: type.key,
+        })),
+    }),
+};

package/dist/resolvers/appKey.d.ts

@@ -0,0 +1,6 @@
+export interface AppKeyResolver {
+    type: "static";
+    inputType?: "text" | "password" | "email";
+    placeholder?: string;
+}
+export declare const appKeyResolver: AppKeyResolver;

package/dist/resolvers/appKey.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appKeyResolver = void 0;
+exports.appKeyResolver = {
+    type: "static",
+    inputType: "text",
+    placeholder: "Enter app slug (e.g., 'slack', 'github')",
+};

package/dist/resolvers/authenticationId.d.ts

@@ -0,0 +1,8 @@
+import type { ZapierSdk } from "../types/sdk";
+export interface AuthenticationIdResolver {
+    type: "dynamic";
+    depends: readonly string[];
+    fetch: (sdk: ZapierSdk, resolvedParams: Record<string, any>) => Promise<any[]>;
+    prompt: (items: any[], params: Record<string, any>) => any;
+}
+export declare const authenticationIdResolver: AuthenticationIdResolver;

package/dist/resolvers/authenticationId.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authenticationIdResolver = void 0;
+exports.authenticationIdResolver = {
+    type: "dynamic",
+    depends: ["appKey"],
+    fetch: async (sdk, resolvedParams) => {
+        // Get auths for the specific app (owned auths will be prioritized automatically)
+        return await sdk.listAuthentications({
+            appKey: resolvedParams.appKey,
+            limit: 1000,
+        });
+    },
+    prompt: (auths, params) => ({
+        type: "list",
+        name: "authenticationId",
+        message: `Select authentication for ${params.appKey}:`,
+        choices: [
+            ...auths.map((auth) => ({
+                name: `${auth.title || auth.label || "Authentication"} (ID: ${auth.id})`,
+                value: auth.id,
+            })),
+            {
+                name: "↗ Skip authentication (may fail)",
+                value: null,
+            },
+        ],
+    }),
+};

package/dist/resolvers/index.d.ts

@@ -0,0 +1,39 @@
+export declare const resolverRegistry: {
+    readonly appKey: import("./appKey").AppKeyResolver;
+    readonly actionType: import("./actionType").ActionTypeResolver;
+    readonly actionKey: import("./actionKey").ActionKeyResolver;
+    readonly authenticationId: import("./authenticationId").AuthenticationIdResolver;
+    readonly inputs: import("./inputs").InputsResolver;
+};
+export type ResolverName = keyof typeof resolverRegistry;
+export type ResolverType = (typeof resolverRegistry)[ResolverName];
+/**
+ * Get a resolver by name
+ */
+export declare function getResolver(name: string): ResolverType | undefined;
+/**
+ * Get all resolvers for a list of missing parameters
+ */
+export declare function getResolversForMissingParams(missingParams: string[]): Record<string, ResolverType>;
+/**
+ * Check if a parameter has a resolver
+ */
+export declare function hasResolver(paramName: string): boolean;
+/**
+ * Get all parameter names that have resolvers
+ */
+export declare function getResolvableParams(): string[];
+/**
+ * Resolve dependency chain for a parameter
+ * Returns parameters in the order they need to be resolved
+ */
+export declare function getResolutionOrder(paramName: string, resolved?: Set<string>): string[];
+/**
+ * Get resolution order for multiple parameters
+ */
+export declare function getResolutionOrderForParams(paramNames: string[]): string[];
+export { appKeyResolver } from "./appKey";
+export { actionTypeResolver } from "./actionType";
+export { actionKeyResolver } from "./actionKey";
+export { authenticationIdResolver } from "./authenticationId";
+export { inputsResolver } from "./inputs";