@zapier/zapier-sdk 0.0.2 → 0.1.0

package/dist/functions/listActions/index.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listActions = listActions;
+const api_1 = require("../../api");
+const getApp_1 = require("../getApp");
+/**
+ * List available actions with optional filtering
+ *
+ * This function can be used standalone without instantiating a full SDK,
+ * which enables better tree-shaking in applications that only need this functionality.
+ *
+ * @param options - Filtering and API configuration options
+ * @returns Promise<Action[]> with pagination metadata
+ */
+async function listActions(options = {}) {
+    const api = (0, api_1.getOrCreateApiClient)(options);
+    // If filtering by appKey, use optimized approach with selected_apis parameter
+    if (options.appKey) {
+        try {
+            // Use the standalone getApp function
+            const appData = await (0, getApp_1.getApp)({
+                appKey: options.appKey,
+                api,
+                token: options.token,
+                baseUrl: options.baseUrl,
+                debug: options.debug,
+                fetch: options.fetch,
+            });
+            // Extract implementation name from current_implementation_id (e.g., "SlackCLIAPI@1.20.0" -> "SlackCLIAPI")
+            const implementationId = appData.current_implementation_id?.split("@")[0];
+            if (!implementationId) {
+                throw new Error("No current_implementation_id found for app");
+            }
+            const searchParams = {
+                global: "true",
+                public_only: "true",
+                selected_apis: implementationId,
+            };
+            const data = await api.get("/api/v4/implementations/", {
+                searchParams,
+            });
+            const actions = [];
+            // Transform implementations to actions
+            for (const implementation of data.results || []) {
+                if (implementation.actions) {
+                    for (const action of implementation.actions) {
+                        const transformedAction = {
+                            key: action.key,
+                            name: action.name || action.label,
+                            description: action.description || "",
+                            appKey: implementation.slug || "",
+                            type: action.type || action.type_of || "read",
+                            inputFields: [], // Would need additional API call for detailed fields
+                            outputFields: [],
+                        };
+                        // Apply type filter if provided
+                        if (options?.type && transformedAction.type !== options.type) {
+                            continue;
+                        }
+                        actions.push(transformedAction);
+                    }
+                }
+            }
+            // Add pagination metadata for app-specific queries
+            if (actions.length > 0) {
+                actions.__pagination = {
+                    count: data.count,
+                    hasNext: !!data.next,
+                    hasPrevious: !!data.previous,
+                    nextUrl: data.next,
+                    previousUrl: data.previous,
+                };
+            }
+            return actions;
+        }
+        catch (error) {
+            // If it's an AppNotFoundError, don't try fallback - just re-throw
+            if (error instanceof Error && error.name === "AppNotFoundError") {
+                throw error;
+            }
+            // Fallback to original approach if optimized approach fails
+            console.warn("Optimized app lookup failed, falling back to full scan:", error);
+        }
+    }
+    // Original approach for general queries or when optimization fails
+    const searchParams = {
+        global: "true",
+        public_only: "true",
+    };
+    const data = await api.get("/api/v4/implementations/", { searchParams });
+    const actions = [];
+    // Transform implementations to actions
+    for (const implementation of data.results || []) {
+        if (implementation.actions) {
+            for (const action of implementation.actions) {
+                const transformedAction = {
+                    key: action.key,
+                    name: action.name || action.label,
+                    description: action.description || "",
+                    appKey: implementation.slug || "",
+                    type: action.type || action.type_of || "read",
+                    inputFields: [], // Would need additional API call for detailed fields
+                    outputFields: [],
+                };
+                // Apply filters
+                if (options?.appKey && transformedAction.appKey !== options.appKey) {
+                    continue;
+                }
+                if (options?.type && transformedAction.type !== options.type) {
+                    continue;
+                }
+                actions.push(transformedAction);
+            }
+        }
+    }
+    // Add pagination metadata for general queries
+    if (actions.length > 0) {
+        actions.__pagination = {
+            count: data.count,
+            hasNext: !!data.next,
+            hasPrevious: !!data.previous,
+            nextUrl: data.next,
+            previousUrl: data.previous,
+        };
+    }
+    return actions;
+}
+// No registry info here - moved to info.ts for proper tree-shaking

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

@@ -0,0 +1,15 @@
+import { listActions } from "./index";
+export declare const listActionsInfo: {
+    name: string;
+    inputSchema: import("zod").ZodObject<{
+        appKey: import("zod").ZodOptional<import("zod").ZodString>;
+        type: import("zod").ZodOptional<import("zod").ZodEnum<["read", "write", "search", "create", "update", "delete"]>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        type?: "create" | "update" | "search" | "delete" | "read" | "write" | undefined;
+        appKey?: string | undefined;
+    }, {
+        type?: "create" | "update" | "search" | "delete" | "read" | "write" | undefined;
+        appKey?: string | undefined;
+    }>;
+    implementation: typeof listActions;
+};

package/dist/functions/listActions/info.js

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

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

@@ -0,0 +1,27 @@
+import { z } from "zod";
+import type { Action } from "../../types/domain";
+export declare const ListActionsSchema: z.ZodObject<{
+    appKey: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodEnum<["read", "write", "search", "create", "update", "delete"]>>;
+}, "strip", z.ZodTypeAny, {
+    type?: "create" | "update" | "search" | "delete" | "read" | "write" | undefined;
+    appKey?: string | undefined;
+}, {
+    type?: "create" | "update" | "search" | "delete" | "read" | "write" | undefined;
+    appKey?: string | undefined;
+}>;
+export type ListActionsOptions = z.infer<typeof ListActionsSchema> & {
+    /** Base URL for Zapier API */
+    baseUrl?: string;
+    /** Authentication token */
+    token?: string;
+    /** Optional pre-instantiated API client */
+    api?: any;
+    /** Enable debug logging */
+    debug?: boolean;
+    /** Custom fetch implementation */
+    fetch?: typeof globalThis.fetch;
+};
+export interface ListActionsSdkFunction {
+    listActions: (options?: Partial<ListActionsOptions>) => Promise<Action[]>;
+}

package/dist/functions/listActions/schemas.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListActionsSchema = void 0;
+const zod_1 = require("zod");
+const properties_1 = require("../../types/properties");
+const schema_utils_1 = require("../../schema-utils");
+const Action_1 = require("../../schemas/Action");
+// Pure Zod schema - no resolver metadata!
+exports.ListActionsSchema = (0, schema_utils_1.withOutputSchema)(zod_1.z
+    .object({
+    appKey: properties_1.AppKeyPropertySchema.optional(),
+    type: properties_1.ActionTypePropertySchema.optional().describe("Filter actions by type"),
+})
+    .describe("List all actions for a specific app"), Action_1.ActionItemSchema);

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

@@ -0,0 +1,12 @@
+import type { Integration } from "../../types/domain";
+import type { ListAppsOptions } from "./schemas";
+/**
+ * List available apps with optional filtering
+ *
+ * This function can be used standalone without instantiating a full SDK,
+ * which enables better tree-shaking in applications that only need this functionality.
+ *
+ * @param options - Filtering, pagination, and API configuration options
+ * @returns Promise<Integration[]> with pagination metadata
+ */
+export declare function listApps(options?: ListAppsOptions): Promise<Integration[]>;

package/dist/functions/listApps/index.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listApps = listApps;
+const api_1 = require("../../api");
+/**
+ * List available apps with optional filtering
+ *
+ * This function can be used standalone without instantiating a full SDK,
+ * which enables better tree-shaking in applications that only need this functionality.
+ *
+ * @param options - Filtering, pagination, and API configuration options
+ * @returns Promise<Integration[]> with pagination metadata
+ */
+async function listApps(options = {}) {
+    const api = (0, api_1.getOrCreateApiClient)(options);
+    // Build search parameters
+    const searchParams = {};
+    if (options.category) {
+        searchParams.category = options.category;
+    }
+    if (options.limit) {
+        searchParams.limit = options.limit.toString();
+    }
+    if (options.offset) {
+        searchParams.offset = options.offset.toString();
+    }
+    const data = await api.get("/api/v4/apps/", { searchParams });
+    // Transform API response to our Integration interface
+    const apps = data.results?.map((app) => ({
+        key: app.slug,
+        name: app.name,
+        description: app.description,
+        version: "1.0.0", // API doesn't provide version
+        category: app.category?.name,
+        actions: [], // Will be populated separately
+        triggers: [],
+        current_implementation_id: app.current_implementation_id,
+    })) || [];
+    // Add pagination metadata to the response
+    if (apps.length > 0) {
+        apps.__pagination = {
+            count: data.count,
+            hasNext: !!data.next,
+            hasPrevious: !!data.previous,
+            nextUrl: data.next,
+            previousUrl: data.previous,
+        };
+    }
+    return apps;
+}

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

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

package/dist/functions/listApps/info.js

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

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

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

package/dist/functions/listApps/schemas.js

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

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

@@ -0,0 +1,12 @@
+import type { Authentication } from "../../types/domain";
+import type { ListAuthsOptions } from "./schemas";
+/**
+ * List available authentications with optional filtering
+ *
+ * This function can be used standalone without instantiating a full SDK,
+ * which enables better tree-shaking in applications that only need this functionality.
+ *
+ * @param options - Filtering, pagination, and API configuration options
+ * @returns Promise<Authentication[]> with pagination metadata
+ */
+export declare function listAuths(options?: Partial<ListAuthsOptions>): Promise<Authentication[]>;

package/dist/functions/listAuths/index.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listAuths = listAuths;
+const api_1 = require("../../api");
+const getApp_1 = require("../getApp");
+/**
+ * List available authentications with optional filtering
+ *
+ * This function can be used standalone without instantiating a full SDK,
+ * which enables better tree-shaking in applications that only need this functionality.
+ *
+ * @param options - Filtering, pagination, and API configuration options
+ * @returns Promise<Authentication[]> with pagination metadata
+ */
+async function listAuths(options = {}) {
+    const { token } = options;
+    if (!token && !process.env.ZAPIER_TOKEN) {
+        throw new Error("Authentication token is required to list authentications. Please provide token in options or set ZAPIER_TOKEN environment variable.");
+    }
+    const api = (0, api_1.getOrCreateApiClient)(options);
+    // Local function to handle the actual API fetching
+    const listAuthsInternal = async (options = {}) => {
+        // Build search parameters
+        const searchParams = {};
+        // Handle appKey filtering by getting the selected_api first
+        if (options.appKey) {
+            try {
+                // Use the standalone getApp function
+                const app = await (0, getApp_1.getApp)({
+                    appKey: options.appKey,
+                    api,
+                    token: options.token,
+                    baseUrl: options.baseUrl,
+                    debug: options.debug,
+                    fetch: options.fetch,
+                });
+                const selectedApi = app.current_implementation_id;
+                if (selectedApi) {
+                    // Use versionless_selected_api to find auths across all app versions
+                    // Extract the base name without the version (e.g., "SlackCLIAPI" from "SlackCLIAPI@1.21.1")
+                    const versionlessApi = selectedApi.split("@")[0];
+                    searchParams.versionless_selected_api = versionlessApi;
+                }
+            }
+            catch (error) {
+                // If it's an AppNotFoundError, re-throw it
+                if (error instanceof Error && error.name === "AppNotFoundError") {
+                    throw error;
+                }
+                // For other errors, continue without app filtering
+                console.warn(`Warning: Could not filter by app ${options.appKey}:`, error instanceof Error ? error.message : "Unknown error");
+            }
+        }
+        // Add other query parameters if provided
+        if (options.account_id) {
+            searchParams.account_id = options.account_id;
+        }
+        if (options.owner) {
+            searchParams.owner = options.owner;
+        }
+        if (options.limit) {
+            searchParams.limit = options.limit.toString();
+        }
+        if (options.offset) {
+            searchParams.offset = options.offset.toString();
+        }
+        const data = await api.get("/api/v4/authentications/", {
+            searchParams,
+            customErrorHandler: (response) => {
+                if (response.status === 401) {
+                    return new Error(`Authentication failed. Your token may not have permission to access authentications or may be expired. (HTTP ${response.status})`);
+                }
+                if (response.status === 403) {
+                    return new Error(`Access forbidden. Your token may not have the required scopes to list authentications. (HTTP ${response.status})`);
+                }
+                return undefined;
+            },
+        });
+        // Transform API response
+        const auths = data.results || [];
+        // Add pagination metadata to the response
+        if (auths.length > 0) {
+            auths.__pagination = {
+                count: data.count,
+                hasNext: !!data.next,
+                hasPrevious: !!data.previous,
+                nextUrl: data.next,
+                previousUrl: data.previous,
+            };
+        }
+        return auths;
+    };
+    // If a limit is provided and no specific owner filter, prioritize owned auths
+    if (options.limit && options.owner === undefined) {
+        // First get owned auths
+        const ownedAuths = await listAuthsInternal({
+            ...options,
+            owner: "me",
+        });
+        // If we have enough owned auths, just slice and return
+        if (ownedAuths.length >= options.limit) {
+            return ownedAuths.slice(0, options.limit);
+        }
+        // Get all auths up to the original limit to fill remaining slots
+        const allAuths = await listAuthsInternal({
+            ...options,
+            owner: undefined,
+        });
+        // Filter out auths the user already owns to avoid duplicates
+        const ownedAuthenticationIds = new Set(ownedAuths.map((auth) => auth.id));
+        const additionalAuths = allAuths.filter((auth) => !ownedAuthenticationIds.has(auth.id));
+        // Combine and slice to the requested limit
+        const combined = [...ownedAuths, ...additionalAuths];
+        return combined.slice(0, options.limit);
+    }
+    // Standard implementation for non-prioritized requests
+    return listAuthsInternal(options);
+}

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

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

package/dist/functions/listAuths/info.js

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

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

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

package/dist/functions/listAuths/schemas.js

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

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

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

package/dist/functions/listFields/index.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listFields = listFields;
+const api_1 = require("../../api");
+const getApp_1 = require("../getApp");
+/**
+ * List available fields for an action
+ *
+ * This function can be used standalone without instantiating a full SDK,
+ * which enables better tree-shaking in applications that only need this functionality.
+ *
+ * @param options - Action details, authentication ID, params, and API configuration options
+ * @returns Promise<ActionField[]>
+ */
+async function listFields(options) {
+    const api = (0, api_1.getOrCreateApiClient)(options);
+    // Extract parameters
+    const { appKey, actionKey, actionType, authenticationId, params } = options;
+    // Use the standalone getApp function
+    const appData = await (0, getApp_1.getApp)({
+        appKey,
+        api,
+        token: options.token,
+        baseUrl: options.baseUrl,
+        debug: options.debug,
+        fetch: options.fetch,
+    });
+    const selectedApi = appData.current_implementation_id;
+    if (!selectedApi) {
+        throw new Error("No current_implementation_id found for app");
+    }
+    // Build needs request
+    const needsRequest = {
+        selected_api: selectedApi,
+        action: actionKey,
+        type_of: actionType,
+        authentication_id: authenticationId,
+        params: params || {},
+    };
+    const needsData = await api.post("/api/v4/implementations/needs/", needsRequest);
+    if (!needsData.success) {
+        throw new Error(`Failed to get action fields: ${needsData.errors?.join(", ") || "Unknown error"}`);
+    }
+    // Transform API response to our ActionField interface
+    return (needsData.needs || []).map((need) => ({
+        key: need.key,
+        label: need.label,
+        required: need.required || false,
+        type: need.type,
+        helpText: need.help_text,
+        helpTextHtml: need.help_text_html,
+        choices: need.choices?.map((choice) => ({
+            value: choice.value,
+            label: choice.label,
+        })),
+        default: need.default,
+        placeholder: need.placeholder,
+        computed: need.computed,
+        customField: need.custom_field,
+        dependsOn: need.depends_on,
+        format: need.format,
+        inputFormat: need.input_format,
+    }));
+}
+// No registry info here - moved to info.ts for proper tree-shaking