@zapier/zapier-sdk 0.18.3 → 0.19.0

package/dist/index.d.ts

@@ -1,40 +1,2541 @@
-export * from "./types/domain";
-export * from "./types/functions";
-export * from "./types/properties";
-export * from "./types/errors";
-export * from "./plugins/apps";
-export * from "./plugins/fetch";
-export * from "./plugins/listApps";
-export * from "./plugins/listActions";
-export * from "./plugins/listInputFields";
-export * from "./plugins/listAuthentications";
-export * from "./plugins/getApp";
-export * from "./plugins/getAction";
-export * from "./plugins/getAuthentication";
-export * from "./plugins/findFirstAuthentication";
-export * from "./plugins/findUniqueAuthentication";
-export * from "./plugins/runAction";
-export * from "./plugins/request";
-export * from "./plugins/manifest";
-export * from "./plugins/getProfile";
-export * from "./plugins/api";
-export type { Action, App, Need, Field, Choice, ActionExecutionResult, ActionField, ActionFieldChoice, NeedsRequest, NeedsResponse, Authentication, AuthenticationsResponse, UserProfile, } from "./api/types";
-export { isPositional, PositionalMetadata } from "./utils/schema-utils";
-export { createFunction } from "./utils/function-utils";
-export type { FormattedItem, FormatMetadata } from "./utils/schema-utils";
-export { toSnakeCase, toTitleCase } from "./utils/string-utils";
-export { batch } from "./utils/batch-utils";
-export type { BatchOptions } from "./utils/batch-utils";
-export * from "./resolvers";
-export * from "./auth";
-export * from "./constants";
-export { RelayRequestSchema, RelayFetchSchema, } from "./plugins/request/schemas";
-export { createZapierSdk, createZapierSdkWithoutRegistry, createSdk, ZapierSdkOptions, } from "./sdk";
-export type { FunctionRegistryEntry } from "./types/sdk";
-export type { Plugin, PluginProvides, PluginDependencies, PluginOptions, GetSdkType, GetContextType, Sdk, } from "./types/plugin";
-export { registryPlugin } from "./plugins/registry";
-export type { ZapierSdk } from "./types/sdk";
-export type { BaseEvent, MethodCalledEvent } from "./types/telemetry-events";
-export type { EventEmissionContext, EventContext, ApplicationLifecycleEventData, EnhancedErrorEventData, MethodCalledEventData, } from "./plugins/eventEmission";
-export { generateEventId, getCurrentTimestamp, getReleaseId, getOsInfo, getPlatformVersions, isCi, getCiPlatform, getMemoryUsage, getCpuTime, buildApplicationLifecycleEvent, buildErrorEventWithContext, buildErrorEvent, createBaseEvent, buildMethodCalledEvent, } from "./plugins/eventEmission";
-//# sourceMappingURL=index.d.ts.map
+import * as zod from 'zod';
+import { z } from 'zod';
+import { AuthenticationSchema, AuthenticationsResponseSchema, AuthenticationItem as AuthenticationItem$1, GetAuthenticationParam, GetAuthenticationResponse, GetAuthenticationParamSchema } from '@zapier/zapier-sdk-core/v0/schemas/authentications';
+import { AppItem as AppItem$1 } from '@zapier/zapier-sdk-core/v0/schemas/apps';
+import * as zod_v4_core from 'zod/v4/core';
+
+/**
+ * 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, unknown>;
+    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;
+
+/**
+ * ------------------------------
+ * Plugin Type System with Explicit Context Dependencies
+ * ------------------------------
+ *
+ * This system makes context dependencies explicit to restore TypeScript's
+ * ability to catch missing context at compile time.
+ */
+
+interface PluginDependencies<TSdk = {}, TContext = {}> {
+    sdk: TSdk;
+    context: TContext;
+}
+interface PluginProvides extends Record<string, any> {
+    context?: Record<string, any>;
+}
+interface PluginMeta {
+    categories: string[];
+    type?: "list" | "item";
+    itemType?: string;
+    returnType?: string;
+    inputSchema: z.ZodSchema;
+    outputSchema?: z.ZodSchema;
+    resolvers?: Record<string, any>;
+    [key: string]: any;
+}
+type ExtractSdkProperties<T extends Record<string, any>> = Omit<T, "context">;
+type ExtractContextProperties<T extends PluginProvides> = T["context"];
+type GetSdkType<TPluginProvides extends PluginProvides> = ExtractSdkProperties<TPluginProvides> & {
+    getContext(): NonNullable<ExtractContextProperties<TPluginProvides>>;
+};
+type GetContextType<TPluginProvides extends PluginProvides> = NonNullable<ExtractContextProperties<TPluginProvides>>;
+type PluginOptions<TSdk = {}, TContext = {}> = {
+    sdk: TSdk;
+    context: TContext & {
+        meta: Record<string, any>;
+    };
+};
+/**
+ * Plugin interface — now has 3 type params:
+ *
+ *   TRequiresContext = what this plugin *needs* in context
+ *   TProvides = what this plugin *returns* (sdk + context)
+ *   TSdk = current sdk shape when plugin runs
+ */
+interface Plugin<TSdk = {}, TRequiresContext = {}, TProvides extends PluginProvides = PluginProvides> {
+    (params: {
+        sdk: TSdk;
+        context: TRequiresContext & {
+            meta: Record<string, PluginMeta>;
+            options: BaseSdkOptions;
+        };
+    }): TProvides;
+}
+type MissingContextKeys<TRequired, TCurrent> = TRequired extends Record<string, any> ? TCurrent extends Record<string, any> ? {
+    [K in keyof TRequired]: K extends keyof TCurrent ? never : K;
+}[keyof TRequired] : keyof TRequired : never;
+type ContextError<TRequired, TCurrent> = MissingContextKeys<TRequired, TCurrent> extends never ? never : MissingContextKeys<TRequired, TCurrent> extends infer Missing ? Missing extends string ? `❌ Missing required context: { ${Missing}: any }` : Missing extends number ? `❌ Missing required context: { ${Missing}: any }` : `❌ Missing required context properties. Required: ${keyof TRequired extends string ? keyof TRequired : "unknown"}, Available: ${keyof TCurrent extends string ? keyof TCurrent : "unknown"}` : "❌ Context requirement not satisfied";
+/**
+ * SDK interface — result of createSdk()
+ *
+ * addPlugin now enforces that TRequiresContext is assignable to TCurrentContext.
+ * If not, TypeScript will emit a detailed error showing missing properties.
+ */
+type Sdk<TCurrentSdk = {}, TCurrentContext = {
+    meta: Record<string, PluginMeta>;
+}> = TCurrentSdk & {
+    addPlugin<TRequiresContext, TProvides extends PluginProvides>(plugin: Plugin<TCurrentSdk & {
+        getContext(): TCurrentContext;
+    }, TRequiresContext, TProvides>, options?: any): TCurrentContext extends TRequiresContext ? Sdk<TCurrentSdk & ExtractSdkProperties<TProvides>, TCurrentContext & NonNullable<ExtractContextProperties<TProvides>>> : ContextError<TRequiresContext, TCurrentContext>;
+    getContext(): TCurrentContext;
+};
+
+/**
+ * Event emission types matching Avro schemas for SDK telemetry
+ *
+ * These interfaces correspond to the Avro schemas:
+ * - application_lifecycle_event.avsc
+ * - error_occurred_event.avsc
+ */
+interface BaseEvent {
+    event_id: string;
+    timestamp_ms: number;
+    release_id: string;
+    customuser_id?: number | null;
+    account_id?: number | null;
+    identity_id?: number | null;
+    visitor_id?: string | null;
+    correlation_id?: string | null;
+}
+interface ErrorOccurredEvent extends BaseEvent {
+    zap_id?: number | null;
+    node_id?: number | null;
+    selected_api?: string | null;
+    app_id?: number | null;
+    app_version_id?: number | null;
+    error_message: string;
+    error_type?: string | null;
+    error_status_code?: number | null;
+    error_stack_trace?: string | null;
+    error_source_method?: string | null;
+    error_source_file?: string | null;
+    error_line_number?: number | null;
+    operation_type?: string | null;
+    operation_key?: string | null;
+    error_severity?: string | null;
+    is_user_facing: boolean;
+    is_recoverable?: boolean | null;
+    sdk_version?: string | null;
+    error_metadata?: Record<string, string | null> | null;
+    parent_error_id?: string | null;
+    error_occurred_timestamp_ms?: number | null;
+    error_code?: string | null;
+    recovery_attempted?: boolean | null;
+    recovery_action?: string | null;
+    recovery_successful?: boolean | null;
+    environment?: string | null;
+    execution_time_before_error_ms?: number | null;
+}
+interface ApplicationLifecycleEvent extends BaseEvent {
+    lifecycle_event_type: "startup" | "exit" | "signal_termination";
+    selected_api?: string | null;
+    app_id?: number | null;
+    app_version_id?: number | null;
+    sdk_version?: string | null;
+    cli_version?: string | null;
+    exit_code?: number | null;
+    signal_name?: string | null;
+    uptime_ms?: number | null;
+    memory_usage_bytes?: number | null;
+    peak_memory_usage_bytes?: number | null;
+    cpu_time_ms?: number | null;
+    os_platform?: string | null;
+    os_release?: string | null;
+    os_architecture?: string | null;
+    platform_versions?: Record<string, string | null> | null;
+    environment?: string | null;
+    is_ci_environment?: boolean | null;
+    ci_platform?: string | null;
+    session_id?: string | null;
+    metadata?: Record<string, string | null> | null;
+    process_argv?: (string | null)[] | null;
+    is_graceful_shutdown?: boolean | null;
+    shutdown_duration_ms?: number | null;
+    active_requests_count?: number | null;
+}
+interface MethodCalledEvent extends BaseEvent {
+    method_name: string;
+    method_module: string | null;
+    execution_duration_ms: number;
+    success_flag: boolean;
+    error_message: string | null;
+    error_type: string | null;
+    argument_count: number;
+    is_paginated: boolean;
+    sdk_version: string;
+    environment: string | null;
+    selected_api: string | null;
+    app_id: number | null;
+    app_version_id: number | null;
+    zap_id: number | null;
+    node_id: number | null;
+    operation_type: string | null;
+    operation_key: string | null;
+    call_context: string | null;
+    is_retry: boolean;
+    retry_attempt: number | null;
+    argument_types: string[] | null;
+    return_type: string | null;
+    caller_method: string | null;
+    call_stack_depth: number | null;
+    is_synchronous: boolean | null;
+    cpu_time_ms: number | null;
+    memory_usage_bytes: number | null;
+}
+
+/**
+ * Transport abstraction layer for event emission
+ *
+ * Provides configurable transport mechanisms for emitting telemetry events.
+ * All transports implement silent failure to prevent SDK disruption.
+ */
+interface EventTransport {
+    emit<T extends any>(subject: string, event: T): Promise<void>;
+    close?(): Promise<void>;
+}
+interface TransportConfig {
+    type: "http" | "console" | "noop";
+    endpoint?: string;
+    headers?: Record<string, string>;
+    retryAttempts?: number;
+    retryDelayMs?: number;
+}
+
+interface EventContext {
+    customuser_id?: number | null;
+    account_id?: number | null;
+    identity_id?: number | null;
+    visitor_id?: string | null;
+    correlation_id?: string | null;
+    selected_api?: string | null;
+    app_id?: number | null;
+    app_version_id?: number | null;
+    zap_id?: number | null;
+    node_id?: number | null;
+    environment?: string | null;
+    sdk_version?: string | null;
+    operation_type?: string | null;
+}
+interface ErrorEventData {
+    error_message: string;
+    is_user_facing: boolean;
+    error_type?: string | null;
+    error_status_code?: number | null;
+    error_stack_trace?: string | null;
+    error_source_method?: string | null;
+    error_source_file?: string | null;
+    error_line_number?: number | null;
+    operation_type?: string | null;
+    operation_key?: string | null;
+    error_severity?: string | null;
+    is_recoverable?: boolean | null;
+    error_metadata?: Record<string, string | null> | null;
+    parent_error_id?: string | null;
+    error_occurred_timestamp_ms?: number | null;
+    error_code?: string | null;
+    recovery_attempted?: boolean | null;
+    recovery_action?: string | null;
+    recovery_successful?: boolean | null;
+    execution_time_before_error_ms?: number | null;
+}
+interface EnhancedErrorEventData extends ErrorEventData {
+    execution_start_time?: number | null;
+}
+interface ApplicationLifecycleEventData {
+    lifecycle_event_type: "startup" | "exit" | "signal_termination";
+    exit_code?: number | null;
+    signal_name?: string | null;
+    uptime_ms?: number | null;
+    is_graceful_shutdown?: boolean | null;
+    shutdown_duration_ms?: number | null;
+    memory_usage_bytes?: number | null;
+    peak_memory_usage_bytes?: number | null;
+    cpu_time_ms?: number | null;
+    active_requests_count?: number | null;
+}
+interface MethodCalledEventData {
+    method_name: string;
+    method_module?: string | null;
+    execution_duration_ms: number;
+    success_flag: boolean;
+    error_message?: string | null;
+    error_type?: string | null;
+    argument_count: number;
+    is_paginated?: boolean;
+}
+
+/**
+ * Event builder utilities for creating telemetry events
+ *
+ * Provides builder functions that auto-populate common fields and ensure
+ * schema compliance for all event types.
+ */
+
+declare function createBaseEvent(context?: EventContext): BaseEvent;
+declare function buildErrorEvent(data: ErrorEventData, context?: EventContext): ErrorOccurredEvent;
+declare function buildApplicationLifecycleEvent(data: ApplicationLifecycleEventData, context?: EventContext): ApplicationLifecycleEvent;
+declare function buildErrorEventWithContext(data: EnhancedErrorEventData, context?: EventContext): ErrorOccurredEvent;
+declare function buildMethodCalledEvent(data: MethodCalledEventData, context?: EventContext): MethodCalledEvent;
+
+/**
+ * Simple utility functions for event emission
+ * These are pure functions that can be used to populate common event fields
+ */
+/**
+ * Generate a unique event ID
+ */
+declare function generateEventId(): string;
+/**
+ * Get current timestamp in milliseconds since epoch
+ */
+declare function getCurrentTimestamp(): number;
+/**
+ * Get release ID (git SHA) - in production this would come from build process
+ */
+declare function getReleaseId(): string;
+/**
+ * Get operating system information
+ */
+declare function getOsInfo(): {
+    platform: string | null;
+    release: string | null;
+    architecture: string | null;
+};
+/**
+ * Get platform versions (Node.js, npm, etc.)
+ */
+declare function getPlatformVersions(): Record<string, string | null>;
+/**
+ * Check if running in CI environment
+ */
+declare function isCi(): boolean;
+/**
+ * Get CI platform name if running in CI
+ */
+declare function getCiPlatform(): string | null;
+/**
+ * Get memory usage in bytes
+ */
+declare function getMemoryUsage(): number | null;
+/**
+ * Get CPU time in milliseconds
+ */
+declare function getCpuTime(): number | null;
+
+/**
+ * Event Emission Plugin for Zapier SDK
+ *
+ * Provides silent telemetry event emission capability to the SDK.
+ * All events are emitted asynchronously and failures are silently handled.
+ */
+
+interface EventEmissionConfig {
+    enabled?: boolean;
+    transport?: TransportConfig;
+}
+interface EventEmissionContext {
+    eventEmission: {
+        transport: EventTransport;
+        config: EventEmissionConfig;
+        emit<T extends any>(subject: string, event: T): void;
+        createBaseEvent(): Promise<BaseEvent>;
+        emitMethodCalled(data: MethodCalledEventData): void;
+    };
+}
+interface EventEmissionProvides {
+    context: EventEmissionContext;
+}
+
+/**
+ * Credentials type definitions
+ *
+ * The credentials system provides a unified way to authenticate with Zapier APIs.
+ * It supports multiple credential types:
+ * - String: A token (JWT or API key) used directly
+ * - Client credentials: OAuth client ID + secret exchanged for a token
+ * - PKCE: OAuth client ID for interactive login (CLI only)
+ * - Function: Lazy/dynamic credential resolution
+ */
+/**
+ * Client credentials for OAuth client_credentials flow.
+ * The SDK will exchange these for an access token.
+ */
+interface ClientCredentialsObject {
+    type?: "client_credentials";
+    clientId: string;
+    clientSecret: string;
+    baseUrl?: string;
+    scope?: string;
+}
+/**
+ * PKCE credentials for interactive OAuth flow.
+ * Only works when @zapier/zapier-sdk-cli-login is available.
+ */
+interface PkceCredentialsObject {
+    type?: "pkce";
+    clientId: string;
+    baseUrl?: string;
+    scope?: string;
+}
+/**
+ * Union of all credential object types.
+ */
+type CredentialsObject = ClientCredentialsObject | PkceCredentialsObject;
+/**
+ * Resolved credentials - what a credentials function must return.
+ * Either a string (token) or a credentials object.
+ * Functions are not allowed to return other functions.
+ */
+type ResolvedCredentials = string | CredentialsObject;
+/**
+ * Credentials can be:
+ * - A string (token or API key)
+ * - A credentials object (client_credentials or pkce)
+ * - A function that returns credentials (sync or async)
+ */
+type Credentials = ResolvedCredentials | (() => ResolvedCredentials | Promise<ResolvedCredentials>);
+/**
+ * Type guard for client credentials objects.
+ */
+declare function isClientCredentials(credentials: ResolvedCredentials): credentials is ClientCredentialsObject;
+/**
+ * Type guard for PKCE credentials objects.
+ */
+declare function isPkceCredentials(credentials: ResolvedCredentials): credentials is PkceCredentialsObject;
+/**
+ * Type guard for credentials objects (either type).
+ */
+declare function isCredentialsObject(credentials: ResolvedCredentials): credentials is CredentialsObject;
+/**
+ * Type guard for credentials functions.
+ */
+declare function isCredentialsFunction(credentials: Credentials): credentials is () => ResolvedCredentials | Promise<ResolvedCredentials>;
+
+declare const NeedSchema: z.ZodObject<{
+    key: z.ZodString;
+    alters_custom_fields: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    capabilities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    choices: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodOptional<z.ZodString>;
+        label: z.ZodOptional<z.ZodString>;
+        sample: z.ZodOptional<z.ZodString>;
+        value: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    computed: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    custom_field: z.ZodOptional<z.ZodBoolean>;
+    default: z.ZodOptional<z.ZodString>;
+    depends_on: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    format: z.ZodOptional<z.ZodLiteral<"SELECT">>;
+    from_search: z.ZodOptional<z.ZodBoolean>;
+    from_write: z.ZodOptional<z.ZodBoolean>;
+    help_text: z.ZodOptional<z.ZodString>;
+    help_text_html: z.ZodOptional<z.ZodString>;
+    input_format: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    label: z.ZodOptional<z.ZodString>;
+    language: z.ZodOptional<z.ZodString>;
+    parent_key: z.ZodOptional<z.ZodString>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    prefill: z.ZodOptional<z.ZodString>;
+    required: z.ZodOptional<z.ZodBoolean>;
+    searchfill: z.ZodOptional<z.ZodString>;
+    send_in_json: z.ZodOptional<z.ZodBoolean>;
+    regex: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodEnum<{
+        string: "string";
+        boolean: "boolean";
+        file: "file";
+        integer: "integer";
+        text: "text";
+        datetime: "datetime";
+        decimal: "decimal";
+        copy: "copy";
+        password: "password";
+        dict: "dict";
+        code: "code";
+        filter: "filter";
+        json: "json";
+    }>>;
+    list: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const ActionSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    type: z.ZodEnum<{
+        search: "search";
+        filter: "filter";
+        read: "read";
+        read_bulk: "read_bulk";
+        run: "run";
+        search_and_write: "search_and_write";
+        search_or_write: "search_or_write";
+        write: "write";
+    }>;
+    key: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    is_important: z.ZodOptional<z.ZodBoolean>;
+    is_hidden: z.ZodOptional<z.ZodBoolean>;
+    selected_api: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const ChoiceSchema: z.ZodObject<{
+    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    label: z.ZodString;
+}, z.core.$strip>;
+declare const FieldSchema: z.ZodObject<{
+    key: z.ZodString;
+    label: z.ZodString;
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        object: "object";
+        file: "file";
+        array: "array";
+        datetime: "datetime";
+    }>;
+    required: z.ZodBoolean;
+    description: z.ZodOptional<z.ZodString>;
+    choices: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+        label: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+declare const ActionExecutionResultSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodUnknown>;
+}, z.core.$strip>;
+declare const ActionFieldChoiceSchema: z.ZodObject<{
+    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    label: z.ZodString;
+}, z.core.$strip>;
+declare const ActionFieldSchema: z.ZodObject<{
+    key: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    required: z.ZodBoolean;
+    type: z.ZodOptional<z.ZodString>;
+    helpText: z.ZodOptional<z.ZodString>;
+    helpTextHtml: z.ZodOptional<z.ZodString>;
+    choices: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+        label: z.ZodString;
+    }, z.core.$strip>>>;
+    default: z.ZodOptional<z.ZodString>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    computed: z.ZodOptional<z.ZodBoolean>;
+    customField: z.ZodOptional<z.ZodBoolean>;
+    dependsOn: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    format: z.ZodOptional<z.ZodString>;
+    inputFormat: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+declare const UserProfileSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    code: z.ZodString;
+    user_id: z.ZodNumber;
+    auto_provisioned: z.ZodBoolean;
+    first_name: z.ZodString;
+    last_name: z.ZodString;
+    username: z.ZodString;
+    personas: z.ZodString;
+    user_generated_personas: z.ZodString;
+    last_login: z.ZodString;
+    email: z.ZodString;
+    email_hash: z.ZodString;
+    email_confirmed: z.ZodBoolean;
+    timezone: z.ZodString;
+    photo_url: z.ZodString;
+    has_seen_notifications: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodBoolean>>;
+    signup: z.ZodString;
+    since_signup: z.ZodString;
+    has_activated: z.ZodBoolean;
+    enable_gz_creator: z.ZodBoolean;
+    should_see_nps_survey: z.ZodBoolean;
+    is_developer: z.ZodBoolean;
+    is_expert: z.ZodBoolean;
+    tos_agreement: z.ZodBoolean;
+    should_renew_tos: z.ZodBoolean;
+    is_gdpr_consented: z.ZodBoolean;
+    disable_ssl_check: z.ZodBoolean;
+    identity: z.ZodNumber;
+    summary_schedule: z.ZodString;
+    alert_triggers: z.ZodString;
+    alert_actions: z.ZodString;
+    is_staff: z.ZodBoolean;
+    is_zt_reviewer: z.ZodBoolean;
+    is_high_value: z.ZodBoolean;
+    is_temporary: z.ZodBoolean;
+    banner_message: z.ZodString;
+    enable_totp_2fa: z.ZodBoolean;
+    viewed_help: z.ZodRecord<z.ZodString, z.ZodBoolean>;
+    show_editor_migration_mesaging: z.ZodBoolean;
+    switches: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    organizations: z.ZodArray<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    primary_organization: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    has_active_zaps: z.ZodBoolean;
+    has_google_sso: z.ZodBoolean;
+    auth_realm: z.ZodString;
+    roles: z.ZodArray<z.ZodObject<{
+        account_id: z.ZodNumber;
+        role: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const AppSchema: z.ZodObject<{
+    age_in_days: z.ZodOptional<z.ZodString>;
+    api_docs_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    app_profile_url: z.ZodString;
+    banner: z.ZodOptional<z.ZodString>;
+    categories: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    canonical_id: z.ZodOptional<z.ZodString>;
+    current_implementation_id: z.ZodString;
+    days_since_last_update: z.ZodOptional<z.ZodString>;
+    description: z.ZodString;
+    external_url: z.ZodString;
+    hashtag: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodNumber>;
+    image: z.ZodOptional<z.ZodString>;
+    images: z.ZodOptional<z.ZodString>;
+    integration_overview_html: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    internal_id: z.ZodString;
+    invite_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    is_beta: z.ZodOptional<z.ZodString>;
+    is_built_in: z.ZodOptional<z.ZodString>;
+    is_featured: z.ZodOptional<z.ZodString>;
+    is_premium: z.ZodOptional<z.ZodBoolean>;
+    is_public: z.ZodOptional<z.ZodString>;
+    is_upcoming: z.ZodOptional<z.ZodString>;
+    learn_more_url: z.ZodString;
+    name: z.ZodString;
+    popularity: z.ZodNumber;
+    primary_color: z.ZodString;
+    request_count: z.ZodOptional<z.ZodString>;
+    slug: z.ZodString;
+    zap_usage_count: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strip>;
+declare const NeedsRequestSchema: z.ZodObject<{
+    selected_api: z.ZodString;
+    action: z.ZodString;
+    type_of: z.ZodString;
+    authentication_id: z.ZodOptional<z.ZodNumber>;
+    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+declare const NeedsResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    needs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        alters_custom_fields: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        capabilities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        choices: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            key: z.ZodOptional<z.ZodString>;
+            label: z.ZodOptional<z.ZodString>;
+            sample: z.ZodOptional<z.ZodString>;
+            value: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        computed: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        custom_field: z.ZodOptional<z.ZodBoolean>;
+        default: z.ZodOptional<z.ZodString>;
+        depends_on: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        format: z.ZodOptional<z.ZodLiteral<"SELECT">>;
+        from_search: z.ZodOptional<z.ZodBoolean>;
+        from_write: z.ZodOptional<z.ZodBoolean>;
+        help_text: z.ZodOptional<z.ZodString>;
+        help_text_html: z.ZodOptional<z.ZodString>;
+        input_format: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        label: z.ZodOptional<z.ZodString>;
+        language: z.ZodOptional<z.ZodString>;
+        parent_key: z.ZodOptional<z.ZodString>;
+        placeholder: z.ZodOptional<z.ZodString>;
+        prefill: z.ZodOptional<z.ZodString>;
+        required: z.ZodOptional<z.ZodBoolean>;
+        searchfill: z.ZodOptional<z.ZodString>;
+        send_in_json: z.ZodOptional<z.ZodBoolean>;
+        regex: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodEnum<{
+            string: "string";
+            boolean: "boolean";
+            file: "file";
+            integer: "integer";
+            text: "text";
+            datetime: "datetime";
+            decimal: "decimal";
+            copy: "copy";
+            password: "password";
+            dict: "dict";
+            code: "code";
+            filter: "filter";
+            json: "json";
+        }>>;
+        list: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    errors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    last_fetched_at: z.ZodOptional<z.ZodString>;
+    schema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+
+/**
+ * API Client Type Definitions
+ *
+ * This module contains all type definitions related to the Zapier API client,
+ * including configuration options, client interfaces, request/response types,
+ * and API response models.
+ *
+ * API response model types are inferred from Zod schemas defined in api/schemas.ts
+ * to ensure a single source of truth and eliminate duplication.
+ */
+
+interface ApiClient {
+    get: <T = unknown>(path: string, options?: RequestOptions) => Promise<T>;
+    post: <T = unknown>(path: string, data?: unknown, options?: RequestOptions) => Promise<T>;
+    put: <T = unknown>(path: string, data?: unknown, options?: RequestOptions) => Promise<T>;
+    delete: <T = unknown>(path: string, options?: RequestOptions) => Promise<T>;
+    poll: <T = unknown>(path: string, options?: PollOptions) => Promise<T>;
+    fetch: (path: string, init?: RequestInit & {
+        searchParams?: Record<string, string>;
+        authRequired?: boolean;
+    }) => Promise<Response>;
+}
+interface RequestOptions {
+    headers?: Record<string, string>;
+    searchParams?: Record<string, string>;
+    authRequired?: boolean;
+    customErrorHandler?: (errorInfo: {
+        status: number;
+        statusText: string;
+        data: unknown;
+    }) => Error | undefined;
+}
+interface PollOptions extends RequestOptions {
+    initialDelay?: number;
+    timeoutMs?: number;
+    successStatus?: number;
+    pendingStatus?: number;
+    resultExtractor?: (response: unknown) => unknown;
+}
+type Need = z.infer<typeof NeedSchema>;
+type Action = z.infer<typeof ActionSchema>;
+type Choice = z.infer<typeof ChoiceSchema>;
+type Field = z.infer<typeof FieldSchema>;
+type ActionExecutionResult = z.infer<typeof ActionExecutionResultSchema>;
+type ActionFieldChoice = z.infer<typeof ActionFieldChoiceSchema>;
+type ActionField = z.infer<typeof ActionFieldSchema>;
+type Authentication = z.infer<typeof AuthenticationSchema>;
+type AuthenticationsResponse = z.infer<typeof AuthenticationsResponseSchema>;
+type UserProfile = z.infer<typeof UserProfileSchema>;
+type App = z.infer<typeof AppSchema>;
+type NeedsRequest = z.infer<typeof NeedsRequestSchema>;
+type NeedsResponse = z.infer<typeof NeedsResponseSchema>;
+
+/**
+ * Domain utility functions for working with app identifiers and data normalization
+ */
+
+interface AppLocator {
+    lookupAppKey: string;
+    slug?: string;
+    implementationName?: string;
+    version?: string;
+}
+interface ResolvedAppLocator extends AppLocator {
+    implementationName: string;
+}
+
+declare const DEFAULT_CONFIG_PATH: ".zapierrc";
+type ManifestEntry = {
+    implementationName: string;
+    version?: string;
+};
+type GetVersionedImplementationId = (appKey: string) => Promise<string | null>;
+/**
+ * Action entry for storing saved action configurations
+ * The key in the actions record IS the user-provided name
+ */
+declare const ActionEntrySchema: z.ZodObject<{
+    appKey: z.ZodString;
+    actionKey: z.ZodString;
+    actionType: z.ZodString;
+    authenticationId: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+    inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+type ActionEntry = z.infer<typeof ActionEntrySchema>;
+type Manifest = {
+    apps: Record<string, ManifestEntry>;
+    actions?: Record<string, ActionEntry>;
+};
+type ResolveAppKeys = ({ appKeys, }: {
+    appKeys: string[];
+}) => Promise<ResolvedAppLocator[]>;
+declare const ManifestPluginOptionsSchema: z.ZodObject<{
+    manifestPath: z.ZodOptional<z.ZodString>;
+    manifest: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        implementationName: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+
+type ManifestPluginOptions = z.infer<typeof ManifestPluginOptionsSchema>;
+interface UpdateManifestEntryOptions {
+    appKey: string;
+    entry: ManifestEntry;
+    configPath?: string;
+    skipWrite?: boolean;
+    manifest?: Manifest;
+}
+interface UpdateManifestEntryResult {
+    key: string;
+    entry: ManifestEntry;
+    manifest: Manifest;
+}
+interface AddActionEntryOptions {
+    name: string;
+    entry: ActionEntry;
+    configPath?: string;
+    skipWrite?: boolean;
+    manifest?: Manifest;
+}
+interface AddActionEntryResult {
+    name: string;
+    entry: ActionEntry;
+    manifest: Manifest;
+}
+interface ManifestPluginProvides {
+    context: {
+        getVersionedImplementationId: GetVersionedImplementationId;
+        resolveAppKeys: ResolveAppKeys;
+        updateManifestEntry: (options: UpdateManifestEntryOptions) => Promise<UpdateManifestEntryResult>;
+        addActionEntry: (options: AddActionEntryOptions) => Promise<AddActionEntryResult>;
+        findActionEntry: (options: {
+            name: string;
+            manifest: Manifest;
+        }) => ActionEntry | null;
+        listActionEntries: (options?: {
+            configPath?: string;
+        }) => Promise<Array<[string, ActionEntry]>>;
+        deleteActionEntry: (options: {
+            name: string;
+            configPath?: string;
+            skipWrite?: boolean;
+        }) => Promise<Manifest>;
+        hasActionEntry: (options: {
+            name: string;
+            manifest: Manifest;
+        }) => boolean;
+        findManifestEntry: (options: {
+            appKey: string;
+            manifest: Manifest;
+        }) => [string, ManifestEntry] | null;
+        readManifestFromFile: (filePath: string) => Promise<Manifest | null>;
+    };
+}
+/**
+ * Read manifest from a file path asynchronously
+ * Supports local files (Node.js) and browser environments (fallback to global filesystem)
+ */
+declare function readManifestFromFile(filePath: string): Promise<Manifest | null>;
+/**
+ * Get the preferred key for storing an app in the manifest
+ * Extracted from plugin to make it easier to test
+ */
+declare function getPreferredManifestEntryKey({ appKey, api, }: {
+    appKey: string;
+    api: ApiClient;
+}): Promise<string>;
+/**
+ * Find a manifest entry by any app key (implementation name, slug, etc.).
+ */
+declare function findManifestEntry({ appKey, manifest, }: {
+    appKey: string;
+    manifest: Manifest;
+}): [string, ManifestEntry] | null;
+
+declare const manifestPlugin: Plugin<{}, // no SDK dependencies
+{
+    api: ApiClient;
+}, ManifestPluginProvides>;
+
+/**
+ * Function-related types and interfaces
+ */
+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?: ApiClient;
+    /** Enable debug logging */
+    debug?: boolean;
+    /** Custom fetch implementation */
+    fetch?: typeof globalThis.fetch;
+}
+type PaginatedSdkFunction<TOptions, TItem> = (options: TOptions) => Promise<{
+    data: TItem[];
+}> & AsyncIterable<{
+    data: TItem[];
+    nextCursor?: string;
+}> & {
+    items(): AsyncIterable<TItem>;
+};
+
+/**
+ * Standard error format returned by the Zapier API
+ */
+interface ApiError {
+    status: number;
+    code: string;
+    title: string;
+    detail: string;
+    source?: unknown;
+    meta?: unknown;
+}
+/**
+ * Base options for all error constructors
+ */
+interface ErrorOptions {
+    statusCode?: number;
+    errors?: ApiError[];
+    cause?: unknown;
+    response?: unknown;
+}
+/**
+ * Base class for all Zapier SDK errors
+ * Use instanceof ZapierError to check if an error is from the SDK
+ */
+declare abstract class ZapierError extends Error {
+    abstract readonly name: string;
+    statusCode?: number;
+    errors?: ApiError[];
+    cause?: unknown;
+    response?: unknown;
+    constructor(message: string, options?: ErrorOptions);
+}
+/**
+ * Error thrown when API requests fail
+ */
+declare class ZapierApiError extends ZapierError {
+    readonly name = "ZapierApiError";
+    constructor(message: string, options?: ErrorOptions);
+}
+/**
+ * Error thrown when an app is not found
+ */
+declare class ZapierAppNotFoundError extends ZapierError {
+    readonly name = "ZapierAppNotFoundError";
+    appKey?: string;
+    constructor(message: string, options?: ErrorOptions & {
+        appKey?: string;
+    });
+}
+/**
+ * Error thrown when validation fails (e.g., invalid parameters)
+ */
+declare class ZapierValidationError extends ZapierError {
+    readonly name = "ZapierValidationError";
+    details?: unknown;
+    constructor(message: string, options?: ErrorOptions & {
+        details?: unknown;
+    });
+}
+/**
+ * Error for unrecognized/unknown errors that get wrapped by safe functions
+ */
+declare class ZapierUnknownError extends ZapierError {
+    readonly name = "ZapierUnknownError";
+    constructor(message: string, options?: ErrorOptions);
+}
+/**
+ * Error thrown for authentication and authorization failures (401/403)
+ */
+declare class ZapierAuthenticationError extends ZapierError {
+    readonly name = "ZapierAuthenticationError";
+    constructor(message: string, options?: ErrorOptions);
+}
+/**
+ * Error thrown when a requested resource is not found
+ */
+declare class ZapierResourceNotFoundError extends ZapierError {
+    readonly name = "ZapierResourceNotFoundError";
+    resourceType?: string;
+    resourceId?: string;
+    constructor(message: string, options?: ErrorOptions & {
+        resourceType?: string;
+        resourceId?: string;
+    });
+}
+/**
+ * Error thrown when required app or implementation configuration is missing
+ */
+declare class ZapierConfigurationError extends ZapierError {
+    readonly name = "ZapierConfigurationError";
+    configType?: string;
+    constructor(message: string, options?: ErrorOptions & {
+        configType?: string;
+    });
+}
+/**
+ * Error thrown when code bundling or compilation fails
+ */
+declare class ZapierBundleError extends ZapierError {
+    readonly name = "ZapierBundleError";
+    buildErrors?: string[];
+    constructor(message: string, options?: ErrorOptions & {
+        buildErrors?: string[];
+    });
+}
+/**
+ * Error thrown when operations timeout or exceed retry limits
+ */
+declare class ZapierTimeoutError extends ZapierError {
+    readonly name = "ZapierTimeoutError";
+    attempts?: number;
+    maxAttempts?: number;
+    constructor(message: string, options?: ErrorOptions & {
+        attempts?: number;
+        maxAttempts?: number;
+    });
+}
+/**
+ * Error thrown when action execution fails due to errors returned from the third-party service
+ * This happens when the Actions API returns a 200 status but includes errors in the response
+ */
+declare class ZapierActionError extends ZapierError {
+    readonly name = "ZapierActionError";
+    appKey?: string;
+    actionKey?: string;
+    constructor(message: string, options?: ErrorOptions & {
+        appKey?: string;
+        actionKey?: string;
+    });
+    get actionErrors(): ApiError[] | undefined;
+}
+/**
+ * Error thrown when a resource is not found (404)
+ */
+declare class ZapierNotFoundError extends ZapierError {
+    readonly name = "ZapierNotFoundError";
+    constructor(message: string, options?: ErrorOptions);
+}
+/**
+ * Utility function to format error messages for display
+ */
+declare function formatErrorMessage(error: ZapierError): string;
+
+declare const ListInputFieldsSchema: z.ZodObject<{
+    appKey: z.ZodString & {
+        _def: z.core.$ZodStringDef & PositionalMetadata;
+    };
+    actionType: z.ZodEnum<{
+        search: "search";
+        filter: "filter";
+        read: "read";
+        read_bulk: "read_bulk";
+        run: "run";
+        search_and_write: "search_and_write";
+        search_or_write: "search_or_write";
+        write: "write";
+    }>;
+    actionKey: z.ZodString;
+    authenticationId: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+    inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    maxItems: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type ListInputFieldsOptions = z.infer<typeof ListInputFieldsSchema>;
+
+declare const FindFirstAuthenticationSchema: z.ZodObject<{
+    search: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+    appKey: z.ZodOptional<z.ZodString & {
+        _def: z.core.$ZodStringDef & PositionalMetadata;
+    }>;
+    accountId: z.ZodOptional<z.ZodString>;
+    owner: z.ZodOptional<z.ZodString>;
+    isExpired: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type FindFirstAuthenticationOptions = z.infer<typeof FindFirstAuthenticationSchema>;
+
+declare const FindUniqueAuthenticationSchema: z.ZodObject<{
+    search: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+    appKey: z.ZodOptional<z.ZodString & {
+        _def: z.core.$ZodStringDef & PositionalMetadata;
+    }>;
+    accountId: z.ZodOptional<z.ZodString>;
+    owner: z.ZodOptional<z.ZodString>;
+    isExpired: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type FindUniqueAuthenticationOptions = z.infer<typeof FindUniqueAuthenticationSchema>;
+
+declare const RelayRequestSchema: z.ZodObject<{
+    url: z.ZodString;
+    method: z.ZodOptional<z.ZodEnum<{
+        POST: "POST";
+        GET: "GET";
+        PUT: "PUT";
+        DELETE: "DELETE";
+        PATCH: "PATCH";
+        HEAD: "HEAD";
+        OPTIONS: "OPTIONS";
+    }>>;
+    body: z.ZodOptional<z.ZodAny>;
+    authenticationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    callbackUrl: z.ZodOptional<z.ZodString>;
+    authenticationTemplate: z.ZodOptional<z.ZodString>;
+    headers: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodString>, z.ZodCustom<Headers, Headers>, z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodString], null>>]>>;
+    relayBaseUrl: z.ZodOptional<z.ZodString>;
+    _telemetry: z.ZodOptional<z.ZodObject<{
+        isNested: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type RelayRequestOptions = z.infer<typeof RelayRequestSchema>;
+declare const RelayFetchSchema: z.ZodObject<{
+    url: z.ZodString;
+    method: z.ZodOptional<z.ZodEnum<{
+        POST: "POST";
+        GET: "GET";
+        PUT: "PUT";
+        DELETE: "DELETE";
+        PATCH: "PATCH";
+        HEAD: "HEAD";
+        OPTIONS: "OPTIONS";
+    }>>;
+    body: z.ZodOptional<z.ZodAny>;
+    authenticationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    callbackUrl: z.ZodOptional<z.ZodString>;
+    authenticationTemplate: z.ZodOptional<z.ZodString>;
+    headers: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodString>, z.ZodCustom<Headers, Headers>, z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodString], null>>]>>;
+    relayBaseUrl: z.ZodOptional<z.ZodString>;
+    _telemetry: z.ZodOptional<z.ZodObject<{
+        isNested: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+
+interface RegistryPluginProvides {
+    getRegistry: (options?: {
+        package?: string;
+    }) => {
+        functions: FunctionRegistryEntry[];
+        categories: {
+            key: string;
+            title: string;
+            titlePlural: string;
+            functions: string[];
+        }[];
+    };
+}
+declare const registryPlugin: Plugin<{}, // accepts any SDK shape
+{}, // requires no context
+RegistryPluginProvides>;
+
+declare const GetProfileSchema: z.ZodOptional<z.ZodObject<{}, z.core.$strip>>;
+type GetProfileOptions = z.infer<typeof GetProfileSchema> & FunctionOptions;
+
+interface GetProfilePluginProvides {
+    getProfile: (options?: GetProfileOptions) => Promise<{
+        data: UserProfileItem;
+    }>;
+    context: {
+        meta: {
+            getProfile: {
+                inputSchema: typeof GetProfileSchema;
+            };
+        };
+    };
+}
+declare const getProfilePlugin: Plugin<{}, // no SDK dependencies
+// no SDK dependencies
+{
+    api: ApiClient;
+} & EventEmissionContext, // requires api and eventEmission in context
+GetProfilePluginProvides>;
+
+interface ApiPluginOptions extends BaseSdkOptions {
+}
+interface ApiPluginProvides {
+    context: {
+        api: ApiClient;
+        resolveCredentials: () => Promise<ResolvedCredentials | undefined>;
+    };
+}
+declare const apiPlugin: Plugin<{}, {}, ApiPluginProvides>;
+
+declare const AppKeyPropertySchema: z.ZodString & {
+    _def: z.core.$ZodStringDef & PositionalMetadata;
+};
+declare const ActionTypePropertySchema: z.ZodEnum<{
+    search: "search";
+    filter: "filter";
+    read: "read";
+    read_bulk: "read_bulk";
+    run: "run";
+    search_and_write: "search_and_write";
+    search_or_write: "search_or_write";
+    write: "write";
+}>;
+declare const ActionKeyPropertySchema: z.ZodString;
+declare const AuthenticationIdPropertySchema: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+declare const InputsPropertySchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+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.ZodUnknown>;
+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>;
+
+declare const ActionExecutionInputSchema: z.ZodObject<{
+    inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    authenticationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+}, z.core.$strip>;
+type ActionExecutionOptions = z.infer<typeof ActionExecutionInputSchema>;
+declare const AppFactoryInputSchema: z.ZodObject<{
+    authenticationId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+}, z.core.$strip>;
+type AppFactoryInput = z.infer<typeof AppFactoryInputSchema>;
+interface BaseActionTypeProxy {
+    [action: string]: (options?: ActionExecutionOptions) => Promise<{
+        data: any[];
+        nextCursor?: string;
+    }> & AsyncIterable<{
+        data: any[];
+        nextCursor?: string;
+    }> & {
+        items(): AsyncIterable<any>;
+    };
+}
+interface FetchActionType {
+    fetch: (url: string | URL, init?: RequestInit & {
+        authenticationId?: AuthenticationIdProperty;
+        callbackUrl?: string;
+        authenticationTemplate?: string;
+    }) => Promise<Response>;
+}
+type ActionTypeProxy = BaseActionTypeProxy & Partial<FetchActionType>;
+interface AppProxy {
+    [type: string]: ActionTypeProxy;
+}
+interface AppFactory {
+    (options: AppFactoryInput): AppProxy;
+}
+type AppProxyWithFactory = AppFactory & AppProxy;
+interface ActionProxy {
+    [app: string]: AppProxyWithFactory;
+}
+
+interface RequestPluginProvides {
+    request: (options: RelayRequestOptions) => Promise<Response>;
+    context: {
+        meta: {
+            request: {
+                inputSchema: typeof RelayRequestSchema;
+            };
+        };
+    };
+}
+declare const requestPlugin: Plugin<{}, // no SDK dependencies
+// no SDK dependencies
+{
+    api: ApiClient;
+} & EventEmissionContext, // requires api in context
+RequestPluginProvides>;
+
+interface FetchPluginProvides {
+    fetch: (url: string | URL, init?: RequestInit & {
+        authenticationId?: string | number;
+        callbackUrl?: string;
+        authenticationTemplate?: string;
+    }) => Promise<Response>;
+    context: {
+        meta: {
+            fetch: {
+                packages: string[];
+                categories: string[];
+                returnType: string;
+                inputParameters: Array<{
+                    name: string;
+                    schema: z.ZodSchema;
+                }>;
+            };
+        };
+    };
+}
+/**
+ * Direct plugin function - takes options + sdk + context in one object
+ */
+declare const fetchPlugin: Plugin<GetSdkType<RequestPluginProvides>, // requires request in SDK
+EventEmissionContext, // requires eventEmission context for telemetry
+FetchPluginProvides>;
+type ZapierFetchInitOptions = RequestInit & {
+    authenticationId?: string | number;
+    callbackUrl?: string;
+    authenticationTemplate?: string;
+};
+
+declare const RunActionSchema: z.ZodObject<{
+    appKey: z.ZodString & {
+        _def: z.core.$ZodStringDef & PositionalMetadata;
+    };
+    actionType: z.ZodEnum<{
+        search: "search";
+        filter: "filter";
+        read: "read";
+        read_bulk: "read_bulk";
+        run: "run";
+        search_and_write: "search_and_write";
+        search_or_write: "search_or_write";
+        write: "write";
+    }>;
+    actionKey: z.ZodString;
+    authenticationId: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+    inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    maxItems: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type RunActionOptions = z.infer<typeof RunActionSchema>;
+
+declare const GetActionSchema: z.ZodObject<{
+    appKey: z.ZodString & {
+        _def: z.core.$ZodStringDef & PositionalMetadata;
+    };
+    actionType: z.ZodEnum<{
+        search: "search";
+        filter: "filter";
+        read: "read";
+        read_bulk: "read_bulk";
+        run: "run";
+        search_and_write: "search_and_write";
+        search_or_write: "search_or_write";
+        write: "write";
+    }>;
+    actionKey: z.ZodString;
+    _telemetry: z.ZodOptional<z.ZodObject<{
+        isNested: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type GetActionOptions = z.infer<typeof GetActionSchema>;
+
+declare const ListActionsSchema: z.ZodObject<{
+    appKey: z.ZodString & {
+        _def: z.core.$ZodStringDef & PositionalMetadata;
+    };
+    actionType: z.ZodOptional<z.ZodEnum<{
+        search: "search";
+        filter: "filter";
+        read: "read";
+        read_bulk: "read_bulk";
+        run: "run";
+        search_and_write: "search_and_write";
+        search_or_write: "search_or_write";
+        write: "write";
+    }>>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    maxItems: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+    _telemetry: z.ZodOptional<z.ZodObject<{
+        isNested: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type ListActionsOptions = z.infer<typeof ListActionsSchema>;
+
+interface ListActionsPluginProvides {
+    listActions: (options?: ListActionsOptions) => Promise<{
+        data: ActionItem$1[];
+        nextCursor?: string;
+    }> & AsyncIterable<{
+        data: ActionItem$1[];
+        nextCursor?: string;
+    }> & {
+        items(): AsyncIterable<ActionItem$1>;
+    };
+    context: {
+        meta: {
+            listActions: {
+                inputSchema: typeof ListActionsSchema;
+            };
+        };
+    };
+}
+declare const listActionsPlugin: Plugin<GetSdkType<ManifestPluginProvides>, {
+    api: ApiClient;
+    getVersionedImplementationId: GetVersionedImplementationId;
+} & EventEmissionContext, ListActionsPluginProvides>;
+
+interface GetActionPluginProvides {
+    getAction: (options: GetActionOptions) => Promise<{
+        data: ActionItem$1;
+    }>;
+    context: {
+        meta: {
+            getAction: {
+                inputSchema: typeof GetActionSchema;
+            };
+        };
+    };
+}
+declare const getActionPlugin: Plugin<GetSdkType<ListActionsPluginProvides>, // requires listActions in SDK
+// requires listActions in SDK
+{
+    api: ApiClient;
+} & EventEmissionContext, // requires api in context
+GetActionPluginProvides>;
+
+declare const GetAppSchema: z.ZodObject<{
+    appKey: z.ZodString & {
+        _def: z.core.$ZodStringDef & PositionalMetadata;
+    };
+}, z.core.$strip>;
+type GetAppOptions = z.infer<typeof GetAppSchema>;
+
+/**
+ * Plugin schemas for listApps
+ *
+ * Imports base query schema from @zapier/zapier-sdk-core (sdkapi) and extends
+ * with SDK-specific options.
+ *
+ * Note: The sdkapi endpoint uses ListAppsQuerySchema (HTTP query params),
+ * but the SDK exposes ListAppsSchema (user-friendly options):
+ * - ListAppsOptions accepts `appKeys` as array, `cursor`, `maxItems`
+ * - ListAppsQuery accepts `appKeys` as comma-separated string, `offset`
+ * - The plugin transforms between these formats
+ */
+
+/**
+ * SDK user-facing options for listApps
+ *
+ * Extends ListAppsQuerySchema from zapier-sdk-core with SDK-specific options:
+ * - appKeys: array (not comma-separated string)
+ * - cursor: pagination cursor (not offset)
+ * - maxItems: SDK-specific pagination limit
+ */
+declare const ListAppsSchema: z.ZodObject<{
+    search: z.ZodOptional<z.ZodString>;
+    appKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    maxItems: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+    _telemetry: z.ZodOptional<z.ZodObject<{
+        isNested: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type ListAppsOptions = z.infer<typeof ListAppsSchema>;
+interface ListAppsPage {
+    data: AppItem$1[];
+    nextCursor?: string;
+}
+
+interface ListAppsPluginProvides {
+    listApps: (options?: ListAppsOptions) => Promise<ListAppsPage> & AsyncIterable<ListAppsPage> & {
+        items(): AsyncIterable<AppItem$1>;
+    };
+    context: {
+        meta: {
+            listApps: {
+                inputSchema: typeof ListAppsSchema;
+            };
+        };
+    };
+}
+declare const listAppsPlugin: Plugin<{}, GetContextType<ApiPluginProvides & ManifestPluginProvides> & EventEmissionContext, ListAppsPluginProvides>;
+
+interface GetAppPluginProvides {
+    getApp: (options: GetAppOptions) => Promise<{
+        data: AppItem;
+    }>;
+    context: {
+        meta: {
+            getApp: {
+                inputSchema: typeof GetAppSchema;
+            };
+        };
+    };
+}
+declare const getAppPlugin: Plugin<GetSdkType<ListAppsPluginProvides>, EventEmissionContext, GetAppPluginProvides>;
+
+interface RunActionPluginProvides {
+    runAction: (options?: RunActionOptions) => Promise<{
+        data: any[];
+        nextCursor?: string;
+    }> & AsyncIterable<{
+        data: any[];
+        nextCursor?: string;
+    }> & {
+        items(): AsyncIterable<any>;
+    };
+    context: {
+        meta: {
+            runAction: {
+                inputSchema: typeof RunActionSchema;
+            };
+        };
+    };
+}
+declare const runActionPlugin: Plugin<GetSdkType<GetActionPluginProvides & GetAppPluginProvides>, // requires getAction and getApp in SDK
+// requires getAction and getApp in SDK
+{
+    api: ApiClient;
+    getVersionedImplementationId: GetVersionedImplementationId;
+} & EventEmissionContext, // requires api and eventEmission in context
+RunActionPluginProvides>;
+
+interface AppsPluginProvides {
+    apps: ActionProxy;
+}
+declare const appsPlugin: Plugin<GetSdkType<FetchPluginProvides & RunActionPluginProvides>, // requires fetch + runAction in SDK
+{}, // no context requirements
+AppsPluginProvides>;
+
+interface ZapierSdkApps {
+}
+
+declare const ListAuthenticationsQuerySchema: z.ZodObject<{
+    search: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+    accountId: z.ZodOptional<z.ZodString>;
+    owner: z.ZodOptional<z.ZodString>;
+    isExpired: z.ZodOptional<z.ZodBoolean>;
+    appKey: z.ZodOptional<z.ZodString & {
+        _def: z.core.$ZodStringDef & PositionalMetadata;
+    }>;
+    authenticationIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    maxItems: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+    _telemetry: z.ZodOptional<z.ZodObject<{
+        isNested: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type ListAuthenticationsOptions = z.infer<typeof ListAuthenticationsQuerySchema>;
+interface ListAuthenticationsPage {
+    data: AuthenticationItem$1[];
+    nextCursor?: string;
+}
+
+interface ListAuthenticationsPluginProvides {
+    listAuthentications: (options?: ListAuthenticationsOptions) => Promise<ListAuthenticationsPage> & AsyncIterable<ListAuthenticationsPage> & {
+        items(): AsyncIterable<AuthenticationItem$1>;
+    };
+    context: {
+        meta: {
+            listAuthentications: {
+                inputSchema: typeof ListAuthenticationsQuerySchema;
+            };
+        };
+    };
+}
+declare const listAuthenticationsPlugin: Plugin<GetSdkType<ManifestPluginProvides>, {
+    api: ApiClient;
+    getVersionedImplementationId: GetVersionedImplementationId;
+} & EventEmissionContext, ListAuthenticationsPluginProvides>;
+
+interface GetAuthenticationPluginProvides {
+    getAuthentication: (options: GetAuthenticationParam) => Promise<GetAuthenticationResponse>;
+    context: {
+        meta: {
+            getAuthentication: {
+                inputSchema: typeof GetAuthenticationParamSchema;
+            };
+        };
+    };
+}
+declare const getAuthenticationPlugin: Plugin<{}, // no SDK dependencies
+// no SDK dependencies
+{
+    api: ApiClient;
+} & EventEmissionContext, // requires api in context
+GetAuthenticationPluginProvides>;
+
+interface FindFirstAuthenticationPluginProvides {
+    findFirstAuthentication: (options?: FindFirstAuthenticationOptions) => Promise<{
+        data: AuthenticationItem;
+    }>;
+    context: {
+        meta: {
+            findFirstAuthentication: {
+                inputSchema: typeof FindFirstAuthenticationSchema;
+            };
+        };
+    };
+}
+declare const findFirstAuthenticationPlugin: Plugin<GetSdkType<ListAuthenticationsPluginProvides>, // requires listAuthentications in SDK
+EventEmissionContext, // requires eventEmission in context
+FindFirstAuthenticationPluginProvides>;
+
+interface FindUniqueAuthenticationPluginProvides {
+    findUniqueAuthentication: (options?: FindUniqueAuthenticationOptions) => Promise<{
+        data: AuthenticationItem;
+    }>;
+    context: {
+        meta: {
+            findUniqueAuthentication: {
+                inputSchema: typeof FindUniqueAuthenticationSchema;
+            };
+        };
+    };
+}
+declare const findUniqueAuthenticationPlugin: Plugin<GetSdkType<ListAuthenticationsPluginProvides>, // requires listAuthentications in SDK
+EventEmissionContext, // requires eventEmission in context
+FindUniqueAuthenticationPluginProvides>;
+
+interface ListInputFieldsPluginProvides {
+    listInputFields: (options?: ListInputFieldsOptions) => Promise<{
+        data: RootFieldItem[];
+        nextCursor?: string;
+    }> & AsyncIterable<{
+        data: RootFieldItem[];
+        nextCursor?: string;
+    }> & {
+        items(): AsyncIterable<InputFieldItem | InfoFieldItem | FieldsetItem>;
+    };
+    context: {
+        meta: {
+            listInputFields: {
+                inputSchema: typeof ListInputFieldsSchema;
+            };
+        };
+    };
+}
+declare const listInputFieldsPlugin: Plugin<GetSdkType<GetAppPluginProvides & GetActionPluginProvides>, // requires getApp and getAction in SDK
+// requires getApp and getAction in SDK
+{
+    api: ApiClient;
+    getVersionedImplementationId: GetVersionedImplementationId;
+} & EventEmissionContext, // requires api, getVersionedImplementationId, and eventEmission in context
+ListInputFieldsPluginProvides>;
+
+declare const GetInputFieldsSchemaSchema: z.ZodObject<{
+    appKey: z.ZodString & {
+        _def: z.core.$ZodStringDef & PositionalMetadata;
+    };
+    actionType: z.ZodEnum<{
+        search: "search";
+        filter: "filter";
+        read: "read";
+        read_bulk: "read_bulk";
+        run: "run";
+        search_and_write: "search_and_write";
+        search_or_write: "search_or_write";
+        write: "write";
+    }>;
+    actionKey: z.ZodString;
+    authenticationId: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+    inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+type GetInputFieldsSchemaOptions = z.infer<typeof GetInputFieldsSchemaSchema>;
+
+interface GetInputFieldsSchemaPluginProvides {
+    getInputFieldsSchema: (options: GetInputFieldsSchemaOptions) => Promise<{
+        data: Record<string, unknown>;
+    }>;
+    context: {
+        meta: {
+            getInputFieldsSchema: {
+                inputSchema: typeof GetInputFieldsSchemaSchema;
+            };
+        };
+    };
+}
+
+declare const InputFieldChoiceItemSchema: z.ZodObject<{
+    key: z.ZodOptional<z.ZodString>;
+    label: z.ZodOptional<z.ZodString>;
+    sample: z.ZodOptional<z.ZodString>;
+    value: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type InputFieldChoiceItem = z.infer<typeof InputFieldChoiceItemSchema>;
+declare const ListInputFieldChoicesSchema: z.ZodObject<{
+    appKey: z.ZodString & {
+        _def: z.core.$ZodStringDef & PositionalMetadata;
+    };
+    actionType: z.ZodEnum<{
+        search: "search";
+        filter: "filter";
+        read: "read";
+        read_bulk: "read_bulk";
+        run: "run";
+        search_and_write: "search_and_write";
+        search_or_write: "search_or_write";
+        write: "write";
+    }>;
+    actionKey: z.ZodString;
+    inputFieldKey: z.ZodString;
+    authenticationId: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+    inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    page: z.ZodOptional<z.ZodNumber>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    maxItems: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type ListInputFieldChoicesOptions = z.infer<typeof ListInputFieldChoicesSchema>;
+
+interface ListInputFieldChoicesPluginProvides {
+    listInputFieldChoices: (options: ListInputFieldChoicesOptions) => Promise<{
+        data: InputFieldChoiceItem[];
+        nextCursor?: string;
+    }> & AsyncIterable<{
+        data: InputFieldChoiceItem[];
+        nextCursor?: string;
+    }> & {
+        items(): AsyncIterable<InputFieldChoiceItem>;
+    };
+    context: {
+        meta: {
+            listInputFieldChoices: {
+                inputSchema: typeof ListInputFieldChoicesSchema;
+            };
+        };
+    };
+}
+
+/**
+ * SDK-related types and interfaces
+ */
+
+interface BaseSdkOptions {
+    /**
+     * Authentication credentials. Can be:
+     * - A string (token or API key)
+     * - An object with clientId/clientSecret for client_credentials flow
+     * - An object with clientId (no secret) for PKCE flow
+     * - A function returning any of the above
+     */
+    credentials?: Credentials;
+    /**
+     * @deprecated Use `credentials` instead.
+     */
+    token?: string;
+    onEvent?: EventCallback;
+    fetch?: typeof fetch;
+    baseUrl?: string;
+    trackingBaseUrl?: string;
+    debug?: boolean;
+    manifestPath?: string;
+    manifest?: Manifest;
+    eventEmission?: EventEmissionConfig;
+}
+
+interface FunctionRegistryEntry {
+    name: string;
+    type?: "list" | "item";
+    itemType?: string;
+    returnType?: string;
+    inputSchema?: z.ZodSchema;
+    inputParameters?: Array<{
+        name: string;
+        schema: z.ZodSchema;
+    }>;
+    outputSchema?: z.ZodSchema;
+    categories: string[];
+    resolvers?: Record<string, any>;
+    packages?: string[];
+}
+interface ZapierSdk extends GetSdkType<RegistryPluginProvides & FetchPluginProvides & AppsPluginProvides & ListAppsPluginProvides & ManifestPluginProvides & GetAppPluginProvides & ListActionsPluginProvides & GetActionPluginProvides & RunActionPluginProvides & ListAuthenticationsPluginProvides & GetAuthenticationPluginProvides & FindFirstAuthenticationPluginProvides & FindUniqueAuthenticationPluginProvides & ListInputFieldsPluginProvides & GetInputFieldsSchemaPluginProvides & ListInputFieldChoicesPluginProvides & RequestPluginProvides & GetProfilePluginProvides & EventEmissionProvides & ApiPluginProvides> {
+    apps: ActionProxy & ZapierSdkApps;
+}
+
+declare const InputFieldItemSchema: z.ZodObject<{
+    key: z.ZodString;
+    type: z.ZodLiteral<"input_field">;
+    default_value: z.ZodString;
+    depends_on: z.ZodArray<z.ZodString>;
+    description: z.ZodString;
+    invalidates_input_fields: z.ZodBoolean;
+    is_required: z.ZodBoolean;
+    placeholder: z.ZodString;
+    title: z.ZodString;
+    value_type: z.ZodString;
+    format: z.ZodOptional<z.ZodString>;
+    items: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const InfoFieldItemSchema: z.ZodObject<{
+    key: z.ZodString;
+    type: z.ZodLiteral<"info_field">;
+    description: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type FieldsetItemType = z.infer<typeof InputFieldItemSchema> | z.infer<typeof InfoFieldItemSchema> | FieldsetItem;
+interface FieldsetItem {
+    type: "fieldset";
+    key: string;
+    title: string;
+    fields: FieldsetItemType[];
+}
+declare const RootFieldItemSchema: z.ZodUnion<readonly [z.ZodObject<{
+    key: z.ZodString;
+    type: z.ZodLiteral<"input_field">;
+    default_value: z.ZodString;
+    depends_on: z.ZodArray<z.ZodString>;
+    description: z.ZodString;
+    invalidates_input_fields: z.ZodBoolean;
+    is_required: z.ZodBoolean;
+    placeholder: z.ZodString;
+    title: z.ZodString;
+    value_type: z.ZodString;
+    format: z.ZodOptional<z.ZodString>;
+    items: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    key: z.ZodString;
+    type: z.ZodLiteral<"info_field">;
+    description: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodType<FieldsetItem, unknown, z.core.$ZodTypeInternals<FieldsetItem, unknown>>]>;
+type InputFieldItem$1 = z.infer<typeof InputFieldItemSchema>;
+
+interface FormattedItem {
+    title: string;
+    id?: string;
+    key?: string;
+    keys?: string[];
+    description?: string;
+    data?: unknown;
+    details: Array<{
+        text: string;
+        style: "normal" | "dim" | "accent" | "warning" | "success";
+    }>;
+}
+interface FormatMetadata<TItem = unknown> {
+    format: (item: TItem) => FormattedItem;
+}
+interface PromptConfig {
+    type: "list";
+    name: string;
+    message: string;
+    choices: Array<{
+        name: string;
+        value: unknown;
+    }>;
+}
+interface Resolver {
+    type: string;
+    depends?: readonly string[] | string[];
+}
+interface StaticResolver extends Resolver {
+    type: "static";
+    inputType?: "text" | "password" | "email";
+    placeholder?: string;
+}
+interface DynamicResolver<TItem = unknown, TParams = Record<string, unknown>> extends Resolver {
+    type: "dynamic";
+    fetch: (sdk: ZapierSdk, resolvedParams: TParams) => Promise<TItem[]>;
+    prompt: (items: TItem[], params: TParams) => PromptConfig;
+}
+interface PositionalMetadata {
+    positionalMeta: {
+        positional: true;
+    };
+}
+declare function isPositional(schema: z.ZodType): boolean;
+
+declare const AppItemSchema: z.ZodObject<{
+    slug: z.ZodString;
+    age_in_days: z.ZodOptional<z.ZodNumber>;
+    auth_type: z.ZodOptional<z.ZodString>;
+    banner: z.ZodOptional<z.ZodString>;
+    categories: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+        slug: z.ZodString;
+    }, z.core.$strip>>>;
+    images: z.ZodOptional<z.ZodObject<{
+        url_16x16: z.ZodOptional<z.ZodString>;
+        url_32x32: z.ZodOptional<z.ZodString>;
+        url_64x64: z.ZodOptional<z.ZodString>;
+        url_128x128: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    popularity: z.ZodOptional<z.ZodNumber>;
+    has_filters: z.ZodOptional<z.ZodBoolean>;
+    has_reads: z.ZodOptional<z.ZodBoolean>;
+    has_searches: z.ZodOptional<z.ZodBoolean>;
+    has_searches_or_writes: z.ZodOptional<z.ZodBoolean>;
+    has_upfront_fields: z.ZodOptional<z.ZodBoolean>;
+    has_writes: z.ZodOptional<z.ZodBoolean>;
+    is_beta: z.ZodOptional<z.ZodBoolean>;
+    is_built_in: z.ZodOptional<z.ZodBoolean>;
+    is_deprecated: z.ZodOptional<z.ZodBoolean>;
+    is_featured: z.ZodOptional<z.ZodBoolean>;
+    is_hidden: z.ZodOptional<z.ZodBoolean>;
+    is_invite: z.ZodOptional<z.ZodBoolean>;
+    is_premium: z.ZodOptional<z.ZodBoolean>;
+    is_public: z.ZodOptional<z.ZodBoolean>;
+    is_upcoming: z.ZodOptional<z.ZodBoolean>;
+    visibility: z.ZodOptional<z.ZodString>;
+    actions: z.ZodOptional<z.ZodObject<{
+        read: z.ZodOptional<z.ZodNumber>;
+        read_bulk: z.ZodOptional<z.ZodNumber>;
+        write: z.ZodOptional<z.ZodNumber>;
+        search: z.ZodOptional<z.ZodNumber>;
+        search_or_write: z.ZodOptional<z.ZodNumber>;
+        search_and_write: z.ZodOptional<z.ZodNumber>;
+        filter: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    description: z.ZodOptional<z.ZodString>;
+    primary_color: z.ZodOptional<z.ZodString>;
+    secondary_color: z.ZodOptional<z.ZodString>;
+    classification: z.ZodOptional<z.ZodString>;
+    api_docs_url: z.ZodOptional<z.ZodString>;
+    image: z.ZodOptional<z.ZodString>;
+    title: z.ZodString;
+    key: z.ZodString;
+    implementation_id: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+
+declare const AuthenticationItemSchema: z.ZodObject<{
+    date: z.ZodString;
+    lastchanged: z.ZodOptional<z.ZodString>;
+    destination_selected_api: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    is_invite_only: z.ZodBoolean;
+    is_private: z.ZodBoolean;
+    shared_with_all: z.ZodBoolean;
+    is_stale: z.ZodOptional<z.ZodString>;
+    is_shared: z.ZodOptional<z.ZodString>;
+    marked_stale_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    label: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    identifier: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    url: z.ZodOptional<z.ZodString>;
+    groups: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    members: z.ZodOptional<z.ZodString>;
+    permissions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+    id: z.ZodString;
+    account_id: z.ZodString;
+    implementation_id: z.ZodOptional<z.ZodString>;
+    profile_id: z.ZodOptional<z.ZodString>;
+    is_expired: z.ZodOptional<z.ZodString>;
+    expired_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    app_key: z.ZodOptional<z.ZodString>;
+    app_version: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const AuthItemSchema: z.ZodObject<{
+    date: z.ZodString;
+    lastchanged: z.ZodOptional<z.ZodString>;
+    destination_selected_api: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    is_invite_only: z.ZodBoolean;
+    is_private: z.ZodBoolean;
+    shared_with_all: z.ZodBoolean;
+    is_stale: z.ZodOptional<z.ZodString>;
+    is_shared: z.ZodOptional<z.ZodString>;
+    marked_stale_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    label: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    identifier: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    url: z.ZodOptional<z.ZodString>;
+    groups: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    members: z.ZodOptional<z.ZodString>;
+    permissions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+    id: z.ZodString;
+    account_id: z.ZodString;
+    implementation_id: z.ZodOptional<z.ZodString>;
+    profile_id: z.ZodOptional<z.ZodString>;
+    is_expired: z.ZodOptional<z.ZodString>;
+    expired_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    app_key: z.ZodOptional<z.ZodString>;
+    app_version: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type AuthItem = z.infer<typeof AuthItemSchema>;
+
+declare const ActionItemSchema: z.ZodObject<{
+    key: z.ZodString;
+    id: z.ZodOptional<z.ZodString>;
+    description: z.ZodString;
+    is_important: z.ZodOptional<z.ZodBoolean>;
+    is_hidden: z.ZodOptional<z.ZodBoolean>;
+    app_key: z.ZodString;
+    app_version: z.ZodOptional<z.ZodString>;
+    action_type: z.ZodEnum<{
+        search: "search";
+        filter: "filter";
+        read: "read";
+        read_bulk: "read_bulk";
+        run: "run";
+        search_and_write: "search_and_write";
+        search_or_write: "search_or_write";
+        write: "write";
+    }>;
+    title: z.ZodString;
+    type: z.ZodLiteral<"action">;
+}, z.core.$strip>;
+
+declare const UserProfileItemSchema: z.ZodObject<{
+    id: z.ZodString;
+    first_name: z.ZodString;
+    last_name: z.ZodString;
+    full_name: z.ZodString;
+    email: z.ZodString;
+    email_confirmed: z.ZodBoolean;
+    timezone: z.ZodString;
+}, z.core.$strip>;
+
+/**
+ * Represents an app item returned by getApp and listApps functions
+ * Inferred from AppItemSchema which extends the base App API schema
+ */
+type AppItem = z.infer<typeof AppItemSchema>;
+/**
+ * Represents an authentication item returned by listAuthentications functions
+ * Inferred from AuthenticationItemSchema which extends the base Authentication API schema
+ */
+type AuthenticationItem = z.infer<typeof AuthenticationItemSchema>;
+/**
+ * Represents an action item returned by listActions functions
+ * Inferred from ActionItemSchema which extends the base Action API schema
+ */
+type ActionItem$1 = z.infer<typeof ActionItemSchema>;
+/**
+ * Represents an input field item returned by listInputFields functions
+ * Inferred from InputFieldItemSchema which extends the base Need API schema
+ */
+type InputFieldItem = z.infer<typeof InputFieldItemSchema>;
+/**
+ * Represents an info field item (help text/copy) returned by listInputFields functions
+ * Inferred from InfoFieldItemSchema
+ */
+type InfoFieldItem = z.infer<typeof InfoFieldItemSchema>;
+
+/**
+ * Represents a root field item (any field/fieldset type) returned by listInputFields
+ * Inferred from RootFieldItemSchema - use as RootFieldItem[]
+ */
+type RootFieldItem = z.infer<typeof RootFieldItemSchema>;
+/**
+ * Represents a user profile item returned by getProfile function
+ * Inferred from UserProfileItemSchema which extends the base UserProfile API schema
+ */
+type UserProfileItem = z.infer<typeof UserProfileItemSchema>;
+
+/**
+ * Generic utility functions for creating paginated SDK functions
+ */
+
+/**
+ * Callbacks for telemetry events during function execution
+ */
+interface TelemetryCallbacks {
+    onMethodCalled?: (data: {
+        methodName: string;
+        durationMs: number;
+        success: boolean;
+        error?: Error;
+        argumentCount: number;
+        isPaginated: boolean;
+    }) => void;
+}
+/**
+ * Higher-order function that creates a function from a core function
+ *
+ * @param coreFn - Function that returns T directly or throws errors
+ * @param schema - Optional Zod schema for validation
+ * @param telemetry - Optional telemetry callbacks
+ * @returns A function that normalizes and rethrows errors
+ */
+declare function createFunction<TOptions, TResult, TSchemaOptions extends TOptions = TOptions>(coreFn: (options: TOptions) => Promise<TResult>, schema?: z.ZodSchema<TSchemaOptions>, telemetry?: TelemetryCallbacks): (options?: TOptions) => Promise<TResult>;
+
+/**
+ * String utility functions for the Zapier SDK
+ */
+/**
+ * Converts a string to title case, handling various input formats:
+ * - camelCase: "firstName" → "First Name"
+ * - snake_case: "first_name" → "First Name"
+ * - kebab-case: "first-name" → "First Name"
+ * - mixed formats: "first_name-value" → "First Name Value"
+ */
+declare function toTitleCase(input: string): string;
+/**
+ * Converts a string to snake_case, handling various input formats:
+ * - camelCase: "firstName" → "first_name"
+ * - kebab-case: "first-name" → "first_name"
+ * - title case: "First Name" → "first_name"
+ * - mixed formats: "first-Name Value" → "first_name_value"
+ * - starts with number: "123abc" → "_123abc"
+ */
+declare function toSnakeCase(input: string): string;
+
+/**
+ * Batch Operation Utilities
+ *
+ * This module provides utilities for executing multiple async operations
+ * with concurrency control and retry logic.
+ */
+/**
+ * Options for batch execution
+ */
+interface BatchOptions {
+    /**
+     * Maximum number of concurrent operations (default: 10)
+     * Lower values are more "polite" but slower
+     * Higher values are faster but risk rate limits
+     */
+    concurrency?: number;
+    /**
+     * Whether to retry failed operations (default: true)
+     * When enabled, each operation gets up to MAX_CONSECUTIVE_ERRORS retries
+     */
+    retry?: boolean;
+    /**
+     * Delay in milliseconds between starting batches (default: 100ms)
+     * Adds a small delay between concurrent batches to avoid burst patterns
+     */
+    batchDelay?: number;
+    /**
+     * Overall timeout for the entire batch operation in milliseconds (default: 180000ms / 3 minutes)
+     * When exceeded, throws ZapierTimeoutError and stops processing remaining tasks
+     */
+    timeoutMs?: number;
+    /**
+     * Timeout for individual tasks in milliseconds (default: none)
+     * When set, each task will be cancelled if it exceeds this duration
+     * Tasks that timeout will be marked as rejected in the results
+     */
+    taskTimeoutMs?: number;
+}
+/**
+ * Execute multiple async operations with concurrency limiting and retry logic
+ *
+ * This prevents overwhelming APIs by:
+ * 1. Limiting concurrent operations (worker pool pattern)
+ * 2. Adding small delays between batches to avoid burst detection
+ * 3. Retrying failed operations with exponential backoff
+ *
+ * Problem Solved:
+ * - Rate limit prevention: Steady stream instead of burst requests
+ * - Connection pool management: Stays within browser/Node limits (~6-8 per domain)
+ * - Resilience: Transient failures are retried automatically
+ * - Observability: Returns detailed success/failure info for each operation
+ *
+ * Example Usage:
+ * ```typescript
+ * // Instead of Promise.allSettled (fires all at once):
+ * const results = await Promise.allSettled(
+ *   actions.map(a => sdk.listInputFields(a))
+ * );
+ *
+ * // Use batch (controlled concurrency):
+ * const results = await batch(
+ *   actions.map(a => () => sdk.listInputFields(a)),
+ *   { concurrency: 10, retry: true }
+ * );
+ * ```
+ *
+ * @param tasks - Array of functions that return promises (NOT promises themselves!)
+ * @param options - Configuration for concurrency and retry behavior
+ * @returns Promise resolving to array of settled results (same as Promise.allSettled)
+ */
+declare function batch<T>(tasks: (() => Promise<T>)[], options?: BatchOptions): Promise<PromiseSettledResult<T>[]>;
+
+declare const appKeyResolver: StaticResolver;
+
+interface ActionTypeItem {
+    key: string;
+    name: string;
+}
+declare const actionTypeResolver: DynamicResolver<ActionTypeItem, {
+    appKey: string;
+}>;
+
+interface ActionItem {
+    key: string;
+    title?: string;
+    name?: string;
+    description?: string;
+    action_type: string;
+}
+declare const actionKeyResolver: DynamicResolver<ActionItem, {
+    appKey: string;
+    actionType: ActionTypeProperty;
+}>;
+
+type AuthenticationIdResolver = DynamicResolver<AuthItem, {
+    appKey?: string;
+}>;
+declare const authenticationIdResolver: AuthenticationIdResolver;
+declare const authenticationIdGenericResolver: AuthenticationIdResolver;
+
+type InputsResolver = {
+    type: "fields";
+    depends: readonly string[];
+    fetch: (sdk: any, resolvedParams: {
+        appKey: string;
+        actionKey: string;
+        actionType: ActionTypeProperty;
+        authenticationId: string | number;
+        inputs?: Record<string, unknown>;
+    }) => Promise<RootFieldItem[]>;
+};
+declare const inputsResolver: InputsResolver;
+declare const inputsAllOptionalResolver: InputsResolver;
+
+declare const inputFieldKeyResolver: DynamicResolver<InputFieldItem$1, {
+    appKey: string;
+    actionKey: string;
+    actionType: ActionTypeProperty;
+    authenticationId: string | number;
+    inputs?: Record<string, unknown>;
+}>;
+
+/**
+ * SDK Authentication Utilities
+ *
+ * This module provides SDK-level authentication utilities focused
+ * on token acquisition. It uses the credentials system for resolution
+ * and handles different credential types appropriately.
+ *
+ * CLI-specific functionality like login/logout is handled by the
+ * @zapier/zapier-sdk-cli-login package.
+ */
+
+/**
+ * Options for resolving auth tokens.
+ */
+interface ResolveAuthTokenOptions {
+    credentials?: Credentials;
+    /** @deprecated Use `credentials` instead */
+    token?: string;
+    onEvent?: EventCallback;
+    fetch?: typeof globalThis.fetch;
+    baseUrl?: string;
+}
+/**
+ * Clear the token cache. Useful for testing or forcing re-authentication.
+ */
+declare function clearTokenCache(): void;
+/**
+ * Invalidate a cached token. Called when we get a 401 response.
+ */
+declare function invalidateCachedToken(clientId: string): void;
+/**
+ * Options for getTokenFromCliLogin.
+ */
+interface CliLoginOptions {
+    onEvent?: EventCallback;
+    fetch?: typeof globalThis.fetch;
+    credentials?: {
+        type?: "pkce";
+        clientId: string;
+        baseUrl?: string;
+        scope?: string;
+    };
+}
+/**
+ * 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: CliLoginOptions): Promise<string | undefined>;
+/**
+ * Resolves an auth token from wherever it can be found.
+ *
+ * Resolution order:
+ * 1. Explicit credentials option (or deprecated token option)
+ * 2. Environment variables
+ * 3. CLI login package (if available)
+ *
+ * For different credential types:
+ * - String: Used directly as the token
+ * - Client credentials: Exchanged for an access token (with caching)
+ * - PKCE: Delegates to CLI login (throws if not available)
+ *
+ * Returns undefined if no valid token is found.
+ */
+declare function resolveAuthToken(options?: ResolveAuthTokenOptions): Promise<string | undefined>;
+/**
+ * Invalidate the cached token for the given credentials, if applicable.
+ * This is called when we receive a 401 response, indicating the token
+ * is no longer valid. Only affects client_credentials flow tokens.
+ */
+declare function invalidateCredentialsToken(options: {
+    credentials?: Credentials;
+    token?: string;
+}): Promise<void>;
+
+/**
+ * Credentials Resolution
+ *
+ * This module provides the core logic for resolving credentials from various sources:
+ * - Explicit credentials option
+ * - Deprecated token option
+ * - Environment variables (new and deprecated)
+ * - CLI login stored tokens
+ */
+
+/**
+ * Options for resolving credentials.
+ */
+interface ResolveCredentialsOptions {
+    credentials?: Credentials;
+    /** @deprecated Use `credentials` instead */
+    token?: string;
+    /** SDK base URL - used to derive auth base URL if not specified in credentials */
+    baseUrl?: string;
+}
+/**
+ * Resolve credentials from environment variables.
+ *
+ * Precedence:
+ * 1. ZAPIER_CREDENTIALS (string token)
+ * 2. ZAPIER_CREDENTIALS_CLIENT_ID + ZAPIER_CREDENTIALS_CLIENT_SECRET (client credentials)
+ * 3. ZAPIER_CREDENTIALS_CLIENT_ID alone (PKCE)
+ * 4. Deprecated ZAPIER_TOKEN, ZAPIER_AUTH_* vars (with warnings)
+ *
+ * @param sdkBaseUrl - SDK base URL used to derive auth base URL if not specified
+ */
+declare function resolveCredentialsFromEnv(sdkBaseUrl?: string): ResolvedCredentials | undefined;
+/**
+ * Resolve credentials from all possible sources.
+ *
+ * Precedence:
+ * 1. Explicit credentials option
+ * 2. Deprecated token option (with warning)
+ * 3. Environment variables
+ * 4. CLI login stored token (handled separately in auth.ts)
+ *
+ * If credentials is a function, it is called and must return
+ * a string or credentials object (not another function).
+ *
+ * The baseUrl option is used to derive the auth base URL if not
+ * specified in credentials.
+ */
+declare function resolveCredentials(options?: ResolveCredentialsOptions): Promise<ResolvedCredentials | undefined>;
+/**
+ * Extract the base URL from credentials for use in auth flows.
+ */
+declare function getBaseUrlFromCredentials(credentials: ResolvedCredentials | undefined): string | undefined;
+/**
+ * Extract the client ID from credentials for use in auth flows.
+ */
+declare function getClientIdFromCredentials(credentials: ResolvedCredentials | undefined): string | undefined;
+
+/**
+ * Logging utilities for the SDK
+ */
+/**
+ * Log a deprecation warning. Each unique message is only logged once per process.
+ */
+declare function logDeprecation(message: string): void;
+/**
+ * Reset the set of logged deprecation warnings.
+ * Useful for testing.
+ */
+declare function resetDeprecationWarnings(): void;
+
+/**
+ * SDK Constants
+ *
+ * This module contains shared constants used throughout the SDK.
+ */
+/**
+ * Base URL for Zapier API endpoints
+ */
+declare const ZAPIER_BASE_URL: string;
+/**
+ * Maximum number of items that can be requested per page across all paginated functions
+ */
+declare const MAX_PAGE_LIMIT = 10000;
+/**
+ * Credentials from environment variables
+ */
+declare const ZAPIER_CREDENTIALS: string | undefined;
+declare const ZAPIER_CREDENTIALS_CLIENT_ID: string | undefined;
+declare const ZAPIER_CREDENTIALS_CLIENT_SECRET: string | undefined;
+declare const ZAPIER_CREDENTIALS_BASE_URL: string | undefined;
+declare const ZAPIER_CREDENTIALS_SCOPE: string | undefined;
+/**
+ * Deprecated environment variables (kept for backwards compatibility)
+ */
+declare const ZAPIER_TOKEN: string | undefined;
+declare const ZAPIER_AUTH_BASE_URL: string | undefined;
+declare const ZAPIER_AUTH_CLIENT_ID: string | undefined;
+
+interface ZapierSdkOptions extends BaseSdkOptions {
+}
+declare function createSdk<TCurrentSdk = {}, TCurrentContext extends {
+    meta: Record<string, PluginMeta>;
+} = {
+    meta: Record<string, PluginMeta>;
+}>(options?: ZapierSdkOptions, initialSdk?: TCurrentSdk, initialContext?: TCurrentContext): TCurrentSdk & {
+    getContext: () => TCurrentContext;
+    addPlugin<TRequiresContext, TProvides extends PluginProvides>(plugin: Plugin<TCurrentSdk & {
+        getContext(): TCurrentContext;
+    }, TRequiresContext, TProvides>, addPluginOptions?: Record<string, unknown>): Sdk<TCurrentSdk & ExtractSdkProperties<TProvides>, TCurrentContext & NonNullable<ExtractContextProperties<TProvides>>>;
+};
+declare function createZapierSdkWithoutRegistry(options?: ZapierSdkOptions): Sdk<ExtractSdkProperties<EventEmissionProvides> & ExtractSdkProperties<ApiPluginProvides> & ExtractSdkProperties<ManifestPluginProvides> & ExtractSdkProperties<ListAppsPluginProvides> & ExtractSdkProperties<GetAppPluginProvides> & ExtractSdkProperties<ListActionsPluginProvides> & ExtractSdkProperties<GetActionPluginProvides> & ExtractSdkProperties<ListInputFieldsPluginProvides> & ExtractSdkProperties<GetInputFieldsSchemaPluginProvides> & ExtractSdkProperties<ListInputFieldChoicesPluginProvides> & ExtractSdkProperties<RunActionPluginProvides> & ExtractSdkProperties<ListAuthenticationsPluginProvides> & ExtractSdkProperties<GetAuthenticationPluginProvides> & ExtractSdkProperties<FindFirstAuthenticationPluginProvides> & ExtractSdkProperties<FindUniqueAuthenticationPluginProvides> & ExtractSdkProperties<RequestPluginProvides> & ExtractSdkProperties<FetchPluginProvides> & ExtractSdkProperties<AppsPluginProvides> & ExtractSdkProperties<GetProfilePluginProvides>, {
+    meta: Record<string, PluginMeta>;
+} & EventEmissionContext & {
+    api: ApiClient;
+    resolveCredentials: () => Promise<ResolvedCredentials | undefined>;
+} & {
+    getVersionedImplementationId: GetVersionedImplementationId;
+    resolveAppKeys: ResolveAppKeys;
+    updateManifestEntry: (options: UpdateManifestEntryOptions) => Promise<UpdateManifestEntryResult>;
+    addActionEntry: (options: AddActionEntryOptions) => Promise<AddActionEntryResult>;
+    findActionEntry: (options: {
+        name: string;
+        manifest: Manifest;
+    }) => ActionEntry | null;
+    listActionEntries: (options?: {
+        configPath?: string;
+    }) => Promise<Array<[string, ActionEntry]>>;
+    deleteActionEntry: (options: {
+        name: string;
+        configPath?: string;
+        skipWrite?: boolean;
+    }) => Promise<Manifest>;
+    hasActionEntry: (options: {
+        name: string;
+        manifest: Manifest;
+    }) => boolean;
+    findManifestEntry: (options: {
+        appKey: string;
+        manifest: Manifest;
+    }) => [string, ManifestEntry] | null;
+    readManifestFromFile: (filePath: string) => Promise<Manifest | null>;
+} & {
+    meta: {
+        listApps: {
+            inputSchema: typeof ListAppsSchema;
+        };
+    };
+} & {
+    meta: {
+        getApp: {
+            inputSchema: typeof GetAppSchema;
+        };
+    };
+} & {
+    meta: {
+        listActions: {
+            inputSchema: typeof ListActionsSchema;
+        };
+    };
+} & {
+    meta: {
+        getAction: {
+            inputSchema: typeof GetActionSchema;
+        };
+    };
+} & {
+    meta: {
+        listInputFields: {
+            inputSchema: typeof ListInputFieldsSchema;
+        };
+    };
+} & {
+    meta: {
+        getInputFieldsSchema: {
+            inputSchema: typeof GetInputFieldsSchemaSchema;
+        };
+    };
+} & {
+    meta: {
+        listInputFieldChoices: {
+            inputSchema: typeof ListInputFieldChoicesSchema;
+        };
+    };
+} & {
+    meta: {
+        runAction: {
+            inputSchema: typeof RunActionSchema;
+        };
+    };
+} & {
+    meta: {
+        listAuthentications: {
+            inputSchema: typeof ListAuthenticationsQuerySchema;
+        };
+    };
+} & {
+    meta: {
+        getAuthentication: {
+            inputSchema: zod.ZodObject<{
+                authenticationId: zod.ZodString;
+            }, zod_v4_core.$strip>;
+        };
+    };
+} & {
+    meta: {
+        findFirstAuthentication: {
+            inputSchema: typeof FindFirstAuthenticationSchema;
+        };
+    };
+} & {
+    meta: {
+        findUniqueAuthentication: {
+            inputSchema: typeof FindUniqueAuthenticationSchema;
+        };
+    };
+} & {
+    meta: {
+        request: {
+            inputSchema: typeof RelayRequestSchema;
+        };
+    };
+} & {
+    meta: {
+        fetch: {
+            packages: string[];
+            categories: string[];
+            returnType: string;
+            inputParameters: Array<{
+                name: string;
+                schema: zod.ZodType;
+            }>;
+        };
+    };
+} & {
+    meta: {
+        getProfile: {
+            inputSchema: typeof GetProfileSchema;
+        };
+    };
+}>;
+declare function createZapierSdk(options?: ZapierSdkOptions): ZapierSdk;
+
+export { type Action, type ActionEntry, type ActionExecutionOptions, type ActionExecutionResult, type ActionField, type ActionFieldChoice, type ActionItem$1 as ActionItem, type ActionKeyProperty, ActionKeyPropertySchema, type ActionTypeProperty, ActionTypePropertySchema, type AddActionEntryOptions, type AddActionEntryResult, type ApiError, type ApiEvent, type ApiPluginOptions, type ApiPluginProvides, type App, type AppItem, type AppKeyProperty, AppKeyPropertySchema, type ApplicationLifecycleEventData, type AppsPluginProvides, type AuthEvent, type Authentication, type AuthenticationIdProperty, AuthenticationIdPropertySchema, type AuthenticationItem, type AuthenticationsResponse, type BaseEvent, type BatchOptions, type Choice, type ClientCredentialsObject, type Credentials, type CredentialsObject, DEFAULT_CONFIG_PATH, type DebugProperty, DebugPropertySchema, type EnhancedErrorEventData, type ErrorOptions, type EventCallback, type EventContext, type EventEmissionContext, type FetchPluginProvides, type Field, type FieldsetItem, type FindFirstAuthenticationPluginProvides, type FindUniqueAuthenticationPluginProvides, type FormatMetadata, type FormattedItem, type FunctionOptions, type FunctionRegistryEntry, type GetActionPluginProvides, type GetAppPluginProvides, type GetAuthenticationPluginProvides, type GetContextType, type GetProfilePluginProvides, type GetSdkType, type InfoFieldItem, type InputFieldItem, type InputsProperty, InputsPropertySchema, type LimitProperty, LimitPropertySchema, type ListActionsPluginProvides, type ListAppsPluginProvides, type ListAuthenticationsPluginProvides, type ListInputFieldsPluginProvides, type LoadingEvent, MAX_PAGE_LIMIT, type Manifest, type ManifestEntry, type ManifestPluginOptions, type ManifestPluginProvides, type MethodCalledEvent, type MethodCalledEventData, type Need, type NeedsRequest, type NeedsResponse, type OffsetProperty, OffsetPropertySchema, type OutputProperty, OutputPropertySchema, type PaginatedSdkFunction, type ParamsProperty, ParamsPropertySchema, type PkceCredentialsObject, type Plugin, type PluginDependencies, type PluginOptions, type PluginProvides, type PositionalMetadata, RelayFetchSchema, RelayRequestSchema, type RequestPluginProvides, type ResolveAuthTokenOptions, type ResolveCredentialsOptions, type ResolvedCredentials, type RootFieldItem, type RunActionPluginProvides, type Sdk, type SdkEvent, type UpdateManifestEntryOptions, type UpdateManifestEntryResult, type UserProfile, type UserProfileItem, ZAPIER_AUTH_BASE_URL, ZAPIER_AUTH_CLIENT_ID, ZAPIER_BASE_URL, ZAPIER_CREDENTIALS, ZAPIER_CREDENTIALS_BASE_URL, ZAPIER_CREDENTIALS_CLIENT_ID, ZAPIER_CREDENTIALS_CLIENT_SECRET, ZAPIER_CREDENTIALS_SCOPE, ZAPIER_TOKEN, ZapierActionError, ZapierApiError, ZapierAppNotFoundError, ZapierAuthenticationError, ZapierBundleError, ZapierConfigurationError, ZapierError, type ZapierFetchInitOptions, ZapierNotFoundError, ZapierResourceNotFoundError, type ZapierSdk, type ZapierSdkApps, type ZapierSdkOptions, ZapierTimeoutError, ZapierUnknownError, ZapierValidationError, actionKeyResolver, actionTypeResolver, apiPlugin, appKeyResolver, appsPlugin, authenticationIdGenericResolver, authenticationIdResolver, batch, buildApplicationLifecycleEvent, buildErrorEvent, buildErrorEventWithContext, buildMethodCalledEvent, clearTokenCache, createBaseEvent, createFunction, createSdk, createZapierSdk, createZapierSdkWithoutRegistry, fetchPlugin, findFirstAuthenticationPlugin, findManifestEntry, findUniqueAuthenticationPlugin, formatErrorMessage, generateEventId, getActionPlugin, getAppPlugin, getAuthenticationPlugin, getBaseUrlFromCredentials, getCiPlatform, getClientIdFromCredentials, getCpuTime, getCurrentTimestamp, getMemoryUsage, getOsInfo, getPlatformVersions, getPreferredManifestEntryKey, getProfilePlugin, getReleaseId, getTokenFromCliLogin, inputFieldKeyResolver, inputsAllOptionalResolver, inputsResolver, invalidateCachedToken, invalidateCredentialsToken, isCi, isClientCredentials, isCredentialsFunction, isCredentialsObject, isPkceCredentials, isPositional, listActionsPlugin, listAppsPlugin, listAuthenticationsPlugin, listInputFieldsPlugin, logDeprecation, manifestPlugin, readManifestFromFile, registryPlugin, requestPlugin, resetDeprecationWarnings, resolveAuthToken, resolveCredentials, resolveCredentialsFromEnv, runActionPlugin, toSnakeCase, toTitleCase };