@zapier/zapier-sdk 0.3.0 → 0.4.0

package/dist/index.d.ts

@@ -1,20 +1,840 @@
-export * from "./types/domain";
-export * from "./types/properties";
-export * from "./plugins/apps";
-export { isPositional } from "./schema-utils";
-export * from "./auth";
-export * from "./resolvers";
-export { listAuthentications } from "./functions/listAuthentications";
-export { getAuthentication } from "./functions/getAuthentication";
-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";
-export { getAction } from "./functions/getAction";
-export { runAction } from "./functions/runAction";
-export { listFields } from "./functions/listFields";
-export { generateTypes } from "./functions/generateTypes";
-export { bundleCode } from "./functions/bundleCode";
-export { createZapierSdk, ZapierSdkOptions } from "./sdk";
-export type { ZapierSdk } from "./types/sdk";
+import { z } from 'zod';
+
+interface Integration {
+    key: string;
+    name: string;
+    description: string;
+    version: string;
+    category?: string;
+    actions: Action[];
+    triggers: Trigger[];
+    current_implementation_id?: string;
+}
+interface Action {
+    key: string;
+    name: string;
+    description: string;
+    appKey: string;
+    type: "read" | "read_bulk" | "write" | "run" | "search" | "search_or_write" | "search_and_write" | "filter";
+    inputFields: Field[];
+    outputFields: Field[];
+}
+interface Trigger {
+    key: string;
+    name: string;
+    description: string;
+    appKey: string;
+    type: "instant" | "polling" | "webhook";
+    outputFields: Field[];
+}
+interface Field {
+    key: string;
+    label: string;
+    type: "string" | "number" | "boolean" | "datetime" | "file" | "object" | "array";
+    required: boolean;
+    description?: string;
+    choices?: Choice[];
+}
+interface Choice {
+    value: string | number;
+    label: string;
+}
+interface ActionExecutionResult {
+    success: boolean;
+    data?: any;
+    error?: string;
+    metadata?: {
+        executionTime?: number;
+        requestId?: string;
+    };
+}
+interface ActionField {
+    key: string;
+    label?: string;
+    required: boolean;
+    type?: string;
+    helpText?: string;
+    helpTextHtml?: string;
+    choices?: ActionFieldChoice[];
+    default?: string;
+    placeholder?: string;
+    computed?: boolean;
+    customField?: boolean;
+    dependsOn?: string[];
+    format?: string;
+    inputFormat?: string[];
+}
+interface ActionFieldChoice {
+    value: string | number;
+    label: string;
+}
+interface NeedsRequest {
+    selected_api: string;
+    action: string;
+    type_of: string;
+    authentication_id?: number;
+    params?: Record<string, any>;
+}
+interface NeedsResponse {
+    success: boolean;
+    needs?: ActionField[];
+    errors?: string[];
+}
+interface Authentication {
+    id: number;
+    date: string;
+    lastchanged?: string;
+    account_id: number;
+    customuser_id?: number;
+    selected_api: string;
+    destination_selected_api?: string | null;
+    is_invite_only: boolean;
+    is_private: boolean;
+    shared_with_all: boolean;
+    is_stale?: string;
+    is_shared?: string;
+    marked_stale_at?: string | null;
+    label?: string | null;
+    identifier?: string | null;
+    title?: string | null;
+    url?: string;
+    groups?: string;
+    members?: string;
+    permissions?: Record<string, boolean>;
+}
+interface AuthenticationsResponse {
+    count: number;
+    next?: string | null;
+    previous?: string | null;
+    results: Authentication[];
+}
+
+/**
+ * SDK Event System
+ *
+ * This module provides common event type definitions for the SDK's
+ * event system, including authentication, API, and loading events.
+ */
+interface SdkEvent {
+    type: string;
+    payload?: Record<string, any>;
+    timestamp?: number;
+}
+interface AuthEvent extends SdkEvent {
+    type: "auth_refreshing" | "auth_success" | "auth_error" | "auth_logout";
+    payload?: {
+        message?: string;
+        error?: string;
+        operation?: string;
+    };
+}
+interface ApiEvent extends SdkEvent {
+    type: "api_request" | "api_response" | "api_error";
+    payload?: {
+        url?: string;
+        method?: string;
+        status?: number;
+        duration?: number;
+        error?: string;
+    };
+}
+interface LoadingEvent extends SdkEvent {
+    type: "loading_start" | "loading_end";
+    payload?: {
+        operation?: string;
+        resource?: string;
+    };
+}
+type EventCallback = (event: SdkEvent) => void;
+
+interface ActionExecutionOptions {
+    inputs?: Record<string, any>;
+    authenticationId?: number;
+}
+interface AuthObject {
+    id: number;
+}
+interface BaseSdkOptions {
+    token?: string;
+    getToken?: () => Promise<string | undefined>;
+    onEvent?: EventCallback;
+    fetch?: typeof fetch;
+    baseUrl?: string;
+    debug?: boolean;
+}
+interface FunctionOptions {
+    /** Base URL for Zapier API */
+    baseUrl?: string;
+    /** Authentication token */
+    token?: string;
+    /** Function to dynamically resolve authentication token */
+    getToken?: () => Promise<string | undefined>;
+    /** Optional pre-instantiated API client */
+    api?: any;
+    /** Enable debug logging */
+    debug?: boolean;
+    /** Custom fetch implementation */
+    fetch?: typeof globalThis.fetch;
+}
+declare class ZapierSdkError extends Error {
+    code?: string | undefined;
+    constructor(message: string, code?: string | undefined);
+}
+declare class AppNotFoundError extends ZapierSdkError {
+    appKey: string;
+    constructor(appKey: string);
+}
+
+declare const AppKeyPropertySchema: z.ZodString;
+declare const ActionTypePropertySchema: z.ZodEnum<["read", "read_bulk", "write", "run", "search", "search_or_write", "search_and_write", "filter"]>;
+declare const ActionKeyPropertySchema: z.ZodString;
+declare const AuthenticationIdPropertySchema: z.ZodNumber;
+declare const InputsPropertySchema: z.ZodRecord<z.ZodString, z.ZodAny>;
+declare const LimitPropertySchema: z.ZodDefault<z.ZodNumber>;
+declare const OffsetPropertySchema: z.ZodDefault<z.ZodNumber>;
+declare const OutputPropertySchema: z.ZodString;
+declare const DebugPropertySchema: z.ZodDefault<z.ZodBoolean>;
+declare const ParamsPropertySchema: z.ZodRecord<z.ZodString, z.ZodAny>;
+type AppKeyProperty = z.infer<typeof AppKeyPropertySchema>;
+type ActionTypeProperty = z.infer<typeof ActionTypePropertySchema>;
+type ActionKeyProperty = z.infer<typeof ActionKeyPropertySchema>;
+type AuthenticationIdProperty = z.infer<typeof AuthenticationIdPropertySchema>;
+type InputsProperty = z.infer<typeof InputsPropertySchema>;
+type LimitProperty = z.infer<typeof LimitPropertySchema>;
+type OffsetProperty = z.infer<typeof OffsetPropertySchema>;
+type OutputProperty = z.infer<typeof OutputPropertySchema>;
+type DebugProperty = z.infer<typeof DebugPropertySchema>;
+type ParamsProperty = z.infer<typeof ParamsPropertySchema>;
+
+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;
+interface ActionProxy {
+    [app: string]: AppProxyWithFactory;
+}
+interface AppsPluginSdkExtension {
+    apps: ActionProxy;
+}
+
+declare const ListActionsSchema: z.ZodObject<{
+    appKey: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodEnum<["read", "read_bulk", "write", "run", "search", "search_or_write", "search_and_write", "filter"]>>;
+}, "strip", z.ZodTypeAny, {
+    type?: "read" | "read_bulk" | "write" | "run" | "search" | "search_or_write" | "search_and_write" | "filter" | undefined;
+    appKey?: string | undefined;
+}, {
+    type?: "read" | "read_bulk" | "write" | "run" | "search" | "search_or_write" | "search_and_write" | "filter" | undefined;
+    appKey?: string | undefined;
+}>;
+type ListActionsOptions = z.infer<typeof ListActionsSchema> & FunctionOptions;
+interface ListActionsSdkFunction {
+    listActions: (options?: Partial<ListActionsOptions>) => Promise<Action[]>;
+}
+
+declare const GetActionSchema: z.ZodObject<{
+    appKey: z.ZodString;
+    actionType: z.ZodEnum<["read", "read_bulk", "write", "run", "search", "search_or_write", "search_and_write", "filter"]>;
+    actionKey: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    appKey: string;
+    actionType: "read" | "read_bulk" | "write" | "run" | "search" | "search_or_write" | "search_and_write" | "filter";
+    actionKey: string;
+}, {
+    appKey: string;
+    actionType: "read" | "read_bulk" | "write" | "run" | "search" | "search_or_write" | "search_and_write" | "filter";
+    actionKey: string;
+}>;
+type GetActionOptions = z.infer<typeof GetActionSchema> & FunctionOptions;
+interface GetActionSdkFunction {
+    getAction: (options: GetActionOptions) => Promise<Action>;
+}
+
+declare const GetAppSchema: z.ZodObject<{
+    appKey: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    appKey: string;
+}, {
+    appKey: string;
+}>;
+type GetAppOptions = z.infer<typeof GetAppSchema> & FunctionOptions;
+interface GetAppSdkFunction {
+    getApp: (options: GetAppOptions) => Promise<Integration>;
+}
+
+declare const RunActionSchema: z.ZodObject<{
+    appKey: z.ZodString;
+    actionType: z.ZodEnum<["read", "read_bulk", "write", "run", "search", "search_or_write", "search_and_write", "filter"]>;
+    actionKey: z.ZodString;
+    inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    authenticationId: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    appKey: string;
+    actionType: "read" | "read_bulk" | "write" | "run" | "search" | "search_or_write" | "search_and_write" | "filter";
+    actionKey: string;
+    inputs?: Record<string, any> | undefined;
+    authenticationId?: number | undefined;
+}, {
+    appKey: string;
+    actionType: "read" | "read_bulk" | "write" | "run" | "search" | "search_or_write" | "search_and_write" | "filter";
+    actionKey: string;
+    inputs?: Record<string, any> | undefined;
+    authenticationId?: number | undefined;
+}>;
+type RunActionOptions = z.infer<typeof RunActionSchema> & FunctionOptions;
+interface RunActionSdkFunction {
+    runAction: (options: RunActionOptions) => Promise<ActionExecutionResult>;
+}
+
+declare const ListFieldsSchema: z.ZodObject<{
+    appKey: z.ZodString;
+    actionType: z.ZodEnum<["read", "read_bulk", "write", "run", "search", "search_or_write", "search_and_write", "filter"]>;
+    actionKey: z.ZodString;
+    authenticationId: z.ZodOptional<z.ZodNumber>;
+    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    appKey: string;
+    actionType: "read" | "read_bulk" | "write" | "run" | "search" | "search_or_write" | "search_and_write" | "filter";
+    actionKey: string;
+    params?: Record<string, any> | undefined;
+    authenticationId?: number | undefined;
+}, {
+    appKey: string;
+    actionType: "read" | "read_bulk" | "write" | "run" | "search" | "search_or_write" | "search_and_write" | "filter";
+    actionKey: string;
+    params?: Record<string, any> | undefined;
+    authenticationId?: number | undefined;
+}>;
+type ListFieldsOptions = z.infer<typeof ListFieldsSchema> & FunctionOptions;
+interface ListFieldsSdkFunction {
+    listFields: (options: ListFieldsOptions) => Promise<ActionField[]>;
+}
+
+declare const ListAuthenticationsSchema: z.ZodObject<{
+    appKey: z.ZodOptional<z.ZodString>;
+    search: z.ZodOptional<z.ZodString>;
+    title: 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, {
+    search?: string | undefined;
+    appKey?: string | undefined;
+    title?: string | undefined;
+    account_id?: string | undefined;
+    owner?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}, {
+    search?: string | undefined;
+    appKey?: string | undefined;
+    title?: string | undefined;
+    account_id?: string | undefined;
+    owner?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}>;
+type ListAuthenticationsOptions = z.infer<typeof ListAuthenticationsSchema> & FunctionOptions;
+interface ListAuthenticationsSdkFunction {
+    listAuthentications: (options?: Partial<ListAuthenticationsOptions>) => Promise<Authentication[]>;
+}
+
+declare const GetAuthenticationSchema: z.ZodObject<{
+    authenticationId: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    authenticationId: number;
+}, {
+    authenticationId: number;
+}>;
+type GetAuthenticationOptions = z.infer<typeof GetAuthenticationSchema> & FunctionOptions;
+interface GetAuthenticationSdkFunction {
+    getAuthentication: (options: GetAuthenticationOptions) => Promise<Authentication>;
+}
+
+declare const FindFirstAuthenticationSchema: z.ZodObject<{
+    appKey: z.ZodOptional<z.ZodString>;
+    search: z.ZodOptional<z.ZodString>;
+    title: 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, {
+    search?: string | undefined;
+    appKey?: string | undefined;
+    title?: string | undefined;
+    account_id?: string | undefined;
+    owner?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}, {
+    search?: string | undefined;
+    appKey?: string | undefined;
+    title?: string | undefined;
+    account_id?: string | undefined;
+    owner?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}>;
+type FindFirstAuthenticationOptions = z.infer<typeof FindFirstAuthenticationSchema> & FunctionOptions;
+interface FindFirstAuthenticationSdkFunction {
+    findFirstAuthentication: (options?: Partial<FindFirstAuthenticationOptions>) => Promise<Authentication | null>;
+}
+
+declare const FindUniqueAuthenticationSchema: z.ZodObject<{
+    appKey: z.ZodOptional<z.ZodString>;
+    search: z.ZodOptional<z.ZodString>;
+    title: 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, {
+    search?: string | undefined;
+    appKey?: string | undefined;
+    title?: string | undefined;
+    account_id?: string | undefined;
+    owner?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}, {
+    search?: string | undefined;
+    appKey?: string | undefined;
+    title?: string | undefined;
+    account_id?: string | undefined;
+    owner?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}>;
+type FindUniqueAuthenticationOptions = z.infer<typeof FindUniqueAuthenticationSchema> & FunctionOptions;
+interface FindUniqueAuthenticationSdkFunction {
+    findUniqueAuthentication: (options?: Partial<FindUniqueAuthenticationOptions>) => Promise<Authentication>;
+}
+
+declare const GenerateTypesSchema: z.ZodObject<{
+    appKey: z.ZodString;
+    authenticationId: z.ZodOptional<z.ZodNumber>;
+    output: z.ZodOptional<z.ZodString>;
+    debug: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    appKey: string;
+    debug: boolean;
+    authenticationId?: number | undefined;
+    output?: string | undefined;
+}, {
+    appKey: string;
+    authenticationId?: number | undefined;
+    output?: string | undefined;
+    debug?: boolean | undefined;
+}>;
+type GenerateTypesOptions = z.infer<typeof GenerateTypesSchema> & FunctionOptions;
+interface GenerateTypesSdkFunction {
+    generateTypes: (options: GenerateTypesOptions) => Promise<string>;
+}
+
+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, {
+    limit?: number | undefined;
+    offset?: number | undefined;
+    category?: string | undefined;
+}, {
+    limit?: number | undefined;
+    offset?: number | undefined;
+    category?: string | undefined;
+}>;
+type ListAppsOptions = z.infer<typeof ListAppsSchema> & FunctionOptions;
+interface ListAppsSdkFunction {
+    listApps: (options?: Partial<ListAppsOptions>) => Promise<Integration[]>;
+}
+
+declare const BundleCodeSchema: z.ZodObject<{
+    input: z.ZodString;
+    output: z.ZodOptional<z.ZodString>;
+    string: z.ZodDefault<z.ZodBoolean>;
+    minify: z.ZodDefault<z.ZodBoolean>;
+    target: z.ZodDefault<z.ZodString>;
+    cjs: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    string: boolean;
+    input: string;
+    minify: boolean;
+    target: string;
+    cjs: boolean;
+    output?: string | undefined;
+}, {
+    input: string;
+    string?: boolean | undefined;
+    output?: string | undefined;
+    minify?: boolean | undefined;
+    target?: string | undefined;
+    cjs?: boolean | undefined;
+}>;
+type BundleCodeOptions = z.infer<typeof BundleCodeSchema>;
+interface BundleCodeSdkFunction {
+    bundleCode: (options: BundleCodeOptions) => Promise<string>;
+}
+
+declare const RelayFetchSchema: z.ZodObject<{
+    url: z.ZodString;
+    method: z.ZodOptional<z.ZodEnum<["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]>>;
+    body: z.ZodOptional<z.ZodString>;
+    authenticationId: z.ZodOptional<z.ZodNumber>;
+    callbackUrl: z.ZodOptional<z.ZodString>;
+    authenticationTemplate: z.ZodOptional<z.ZodString>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    authenticationId?: number | undefined;
+    method?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS" | undefined;
+    body?: string | undefined;
+    callbackUrl?: string | undefined;
+    authenticationTemplate?: string | undefined;
+    headers?: Record<string, string> | undefined;
+}, {
+    url: string;
+    authenticationId?: number | undefined;
+    method?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS" | undefined;
+    body?: string | undefined;
+    callbackUrl?: string | undefined;
+    authenticationTemplate?: string | undefined;
+    headers?: Record<string, string> | undefined;
+}>;
+type RelayFetchOptions$1 = z.infer<typeof RelayFetchSchema> & FunctionOptions & {
+    /** Base URL for Relay service */
+    relayBaseUrl?: string;
+};
+interface RelayFetchSdkFunction {
+    fetch: (options: RelayFetchOptions$1) => Promise<Response>;
+}
+
+interface ZapierSdkFunctions extends ListActionsSdkFunction, GetActionSdkFunction, GetAppSdkFunction, RunActionSdkFunction, ListFieldsSdkFunction, ListAuthenticationsSdkFunction, GetAuthenticationSdkFunction, FindFirstAuthenticationSdkFunction, FindUniqueAuthenticationSdkFunction, GenerateTypesSdkFunction, ListAppsSdkFunction, BundleCodeSdkFunction, RelayFetchSdkFunction {
+}
+interface ZapierSdkPlugins extends AppsPluginSdkExtension {
+}
+interface BaseZapierSdk extends ZapierSdkFunctions {
+    __registry: Array<{
+        name: string;
+        inputSchema: any;
+        implementation: Function;
+    }>;
+}
+interface ZapierSdk extends ZapierSdkFunctions, ZapierSdkPlugins {
+    __registry: Array<{
+        name: string;
+        inputSchema: any;
+        implementation: Function;
+    }>;
+}
+
+interface AppsPluginOptions {
+    sdk: ZapierSdk;
+}
+declare function createAppsPlugin(options: AppsPluginOptions): ActionProxy;
+
+declare function isPositional(schema: z.ZodType): boolean;
+
+/**
+ * SDK Authentication Utilities
+ *
+ * This module provides SDK-level authentication utilities focused
+ * solely on token acquisition. CLI-specific functionality like login/logout
+ * is handled by the @zapier/zapier-sdk-cli-login package.
+ */
+
+interface AuthOptions {
+    onEvent?: EventCallback;
+    fetch?: typeof globalThis.fetch;
+}
+/**
+ * Gets the ZAPIER_TOKEN from environment variables.
+ * Returns undefined if not set.
+ */
+declare function getTokenFromEnv(): string | undefined;
+/**
+ * Attempts to get a token by optionally importing from CLI login package.
+ * This provides a graceful fallback when the CLI login package is not available.
+ *
+ * Returns undefined if no valid token is found or CLI package is not available.
+ */
+declare function getTokenFromCliLogin(options?: AuthOptions): Promise<string | undefined>;
+/**
+ * Attempts to get a token with the following precedence:
+ * 1. ZAPIER_TOKEN environment variable
+ * 2. CLI login package (if available) with auto-refresh
+ *
+ * Returns undefined if no valid token is found.
+ */
+declare function getTokenFromEnvOrConfig(options?: AuthOptions): Promise<string | undefined>;
+
+interface InputsResolver {
+    type: "fields";
+    depends: readonly string[];
+    fetch: (sdk: ZapierSdk, resolvedParams: Record<string, any>) => Promise<any[]>;
+}
+declare const inputsResolver: InputsResolver;
+
+interface AuthenticationIdResolver {
+    type: "dynamic";
+    depends: readonly string[];
+    fetch: (sdk: ZapierSdk, resolvedParams: Record<string, any>) => Promise<any[]>;
+    prompt: (items: any[], params: Record<string, any>) => any;
+}
+declare const authenticationIdResolver: AuthenticationIdResolver;
+
+interface ActionKeyResolver {
+    type: "dynamic";
+    depends: readonly string[];
+    fetch: (sdk: ZapierSdk, resolvedParams: Record<string, any>) => Promise<any[]>;
+    prompt: (items: any[], params: Record<string, any>) => any;
+}
+declare const actionKeyResolver: ActionKeyResolver;
+
+interface ActionTypeResolver {
+    type: "dynamic";
+    depends: readonly string[];
+    fetch: (sdk: ZapierSdk, resolvedParams: Record<string, any>) => Promise<any[]>;
+    prompt: (items: any[], params: Record<string, any>) => any;
+}
+declare const actionTypeResolver: ActionTypeResolver;
+
+interface AppKeyResolver {
+    type: "static";
+    inputType?: "text" | "password" | "email";
+    placeholder?: string;
+}
+declare const appKeyResolver: AppKeyResolver;
+
+declare const resolverRegistry: {
+    readonly appKey: AppKeyResolver;
+    readonly actionType: ActionTypeResolver;
+    readonly actionKey: ActionKeyResolver;
+    readonly authenticationId: AuthenticationIdResolver;
+    readonly inputs: InputsResolver;
+};
+type ResolverName = keyof typeof resolverRegistry;
+type ResolverType = (typeof resolverRegistry)[ResolverName];
+/**
+ * Get a resolver by name
+ */
+declare function getResolver(name: string): ResolverType | undefined;
+/**
+ * Get all resolvers for a list of missing parameters
+ */
+declare function getResolversForMissingParams(missingParams: string[]): Record<string, ResolverType>;
+/**
+ * Check if a parameter has a resolver
+ */
+declare function hasResolver(paramName: string): boolean;
+/**
+ * Get all parameter names that have resolvers
+ */
+declare function getResolvableParams(): string[];
+/**
+ * Resolve dependency chain for a parameter
+ * Returns parameters in the order they need to be resolved
+ */
+declare function getResolutionOrder(paramName: string, resolved?: Set<string>): string[];
+/**
+ * Get resolution order for multiple parameters
+ */
+declare function getResolutionOrderForParams(paramNames: string[]): string[];
+
+/**
+ * List available authentications with optional filtering
+ *
+ * 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 - Filtering, pagination, and API configuration options
+ * @returns Promise<Authentication[]> with pagination metadata
+ */
+declare function listAuthentications(options?: Partial<ListAuthenticationsOptions>): Promise<Authentication[]>;
+
+/**
+ * Get a specific authentication by ID
+ *
+ * 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 - Authentication ID and API configuration options
+ * @returns Promise<Authentication> - The authentication details
+ * @throws Error if authentication not found or access denied
+ */
+declare function getAuthentication(options: GetAuthenticationOptions): Promise<Authentication>;
+
+/**
+ * Find the first authentication matching the given criteria
+ *
+ * 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 - Filtering and API configuration options
+ * @returns Promise<Authentication | null> - First matching authentication or null if not found
+ */
+declare function findFirstAuthentication(options?: Partial<FindFirstAuthenticationOptions>): Promise<Authentication | null>;
+
+/**
+ * Find a unique authentication matching the given criteria
+ *
+ * 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 - Filtering and API configuration options
+ * @returns Promise<Authentication> - The unique matching authentication
+ * @throws Error if no authentication found or multiple authentications found
+ */
+declare function findUniqueAuthentication(options?: Partial<FindUniqueAuthenticationOptions>): Promise<Authentication>;
+
+/**
+ * List available apps with optional filtering
+ *
+ * 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 - Filtering, pagination, and API configuration options
+ * @returns Promise<Integration[]> with pagination metadata
+ */
+declare function listApps(options?: ListAppsOptions): Promise<Integration[]>;
+
+/**
+ * Get a specific app by key
+ *
+ * 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 - App key and API configuration options
+ * @returns Promise<Integration>
+ */
+declare function getApp(options: GetAppOptions): Promise<Integration>;
+
+/**
+ * List available actions with optional filtering
+ *
+ * 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 - Filtering and API configuration options
+ * @returns Promise<Action[]> with pagination metadata
+ */
+declare function listActions(options?: Partial<ListActionsOptions>): Promise<Action[]>;
+
+/**
+ * Get a specific action by app, action key, and type
+ *
+ * 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 - App key, action key, type, and API configuration options
+ * @returns Promise<Action>
+ */
+declare function getAction(options: GetActionOptions): Promise<Action>;
+
+/**
+ * Execute 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 execution parameters and API configuration options
+ * @returns Promise<ActionExecutionResult>
+ */
+declare function runAction(options: RunActionOptions): Promise<ActionExecutionResult>;
+
+/**
+ * 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, authentication ID, params, and API configuration options
+ * @returns Promise<ActionField[]>
+ */
+declare function listFields(options: ListFieldsOptions): Promise<ActionField[]>;
+
+/**
+ * Generate TypeScript types for a specific app
+ *
+ * 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 - App key, authentication ID, output path, and API configuration options
+ * @returns Promise<string> - Generated TypeScript code
+ */
+declare function generateTypes(options: GenerateTypesOptions): Promise<string>;
+
+/**
+ * Bundle TypeScript code into executable JavaScript
+ *
+ * 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 - Bundling configuration options
+ * @returns Promise<string> - Bundled JavaScript code
+ */
+declare function bundleCode(options: BundleCodeOptions): Promise<string>;
+
+interface RelayFetchOptions {
+    /** HTTP method */
+    method?: string;
+    /** Request body as a string */
+    body?: string;
+    /** Request headers */
+    headers?: HeadersInit;
+    /** Zapier authentication ID to use for the request */
+    authenticationId?: number;
+    /** URL to send async response to (makes request async) */
+    callbackUrl?: string;
+    /** Optional JSON string authentication template to bypass Notary lookup */
+    authenticationTemplate?: string;
+}
+interface RelayFetchConfig extends FunctionOptions {
+    /** Event callback function */
+    onEvent?: (event: any) => void;
+}
+/**
+ * Fetch function that can make requests to external APIs through Zapier's Relay service
+ *
+ * This function takes full URLs (like https://api.github.com/user) and transforms them
+ * into the relay format (/relay/api.github.com/user) for the API client to route
+ * to relay.zapier.com.
+ *
+ * @param url - The full URL to fetch
+ * @param options - Fetch options with additional Relay-specific parameters
+ * @param config - SDK configuration options
+ * @returns Promise<Response> - The response from the request
+ */
+/**
+ * Schema-compatible wrapper function for the fetch functionality
+ */
+declare function fetch$1(options: {
+    url: string;
+    method?: string;
+    body?: string;
+    headers?: Record<string, string>;
+    authenticationId?: number;
+    callbackUrl?: string;
+    authenticationTemplate?: string;
+} & FunctionOptions): Promise<Response>;
+/**
+ * Internal fetch implementation
+ */
+declare function relayFetch(url: string | URL, options?: RelayFetchOptions, config?: RelayFetchConfig): Promise<Response>;
+
+interface ZapierSdkOptions extends BaseSdkOptions {
+}
+declare function createZapierSdk(options?: ZapierSdkOptions): ZapierSdk;
+
+export { type Action, type ActionExecutionOptions, type ActionExecutionResult, type ActionField, type ActionFieldChoice, type ActionKeyProperty, ActionKeyPropertySchema, type ActionProxy, type ActionTypeProperty, ActionTypePropertySchema, type ApiEvent, type AppKeyProperty, AppKeyPropertySchema, AppNotFoundError, type AppsPluginOptions, type AppsPluginSdkExtension, type AuthEvent, type AuthObject, type AuthOptions, type Authentication, type AuthenticationIdProperty, AuthenticationIdPropertySchema, type AuthenticationsResponse, type BaseSdkOptions, type BaseZapierSdk, type Choice, type DebugProperty, DebugPropertySchema, type EventCallback, type Field, type FunctionOptions, type InputsProperty, InputsPropertySchema, type Integration, type LimitProperty, LimitPropertySchema, type LoadingEvent, type NeedsRequest, type NeedsResponse, type OffsetProperty, OffsetPropertySchema, type OutputProperty, OutputPropertySchema, type ParamsProperty, ParamsPropertySchema, RelayFetchSchema, type ResolverName, type ResolverType, type SdkEvent, type Trigger, type ZapierSdk, ZapierSdkError, type ZapierSdkOptions, actionKeyResolver, actionTypeResolver, appKeyResolver, authenticationIdResolver, bundleCode, createAppsPlugin, createZapierSdk, fetch$1 as fetch, findFirstAuthentication, findUniqueAuthentication, generateTypes, getAction, getApp, getAuthentication, getResolutionOrder, getResolutionOrderForParams, getResolvableParams, getResolver, getResolversForMissingParams, getTokenFromCliLogin, getTokenFromEnv, getTokenFromEnvOrConfig, hasResolver, inputsResolver, isPositional, listActions, listApps, listAuthentications, listFields, relayFetch, resolverRegistry, runAction };