@zapier/zapier-sdk 0.0.1 → 0.0.3

package/dist/functions/listAuths.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)({
+                    key: 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 ownedAuthIds = new Set(ownedAuths.map((auth) => auth.id));
+        const additionalAuths = allAuths.filter((auth) => !ownedAuthIds.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/listFields.d.ts

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

package/dist/functions/listFields.js

@@ -0,0 +1,67 @@
+"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, auth ID, params, and API configuration options
+ * @returns Promise<ActionField[]>
+ */
+async function listFields(options) {
+    const api = (0, api_1.getOrCreateApiClient)(options);
+    // Map consistent parameter names to internal API names
+    const { app, action, type, authId, params } = options;
+    const appKey = app;
+    const actionKey = action;
+    const actionType = type;
+    // Use the standalone getApp function
+    const appData = await (0, getApp_1.getApp)({
+        key: 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: authId,
+        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,
+    }));
+}

package/dist/functions/runAction.d.ts

@@ -0,0 +1,18 @@
+import type { ActionExecutionResult, FunctionConfig } from "../types";
+export interface RunActionOptions extends FunctionConfig {
+    app: string;
+    type: string;
+    action: string;
+    inputs?: Record<string, any>;
+    authId?: number;
+}
+/**
+ * Execute an action
+ *
+ * This function can be used standalone without instantiating a full SDK,
+ * which enables better tree-shaking in applications that only need this functionality.
+ *
+ * @param options - Action execution parameters and API configuration options
+ * @returns Promise<ActionExecutionResult>
+ */
+export declare function runAction(options: RunActionOptions): Promise<ActionExecutionResult>;

package/dist/functions/runAction.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAction = runAction;
+const api_1 = require("../api");
+const getAction_1 = require("./getAction");
+const getApp_1 = require("./getApp");
+/**
+ * Execute an action
+ *
+ * This function can be used standalone without instantiating a full SDK,
+ * which enables better tree-shaking in applications that only need this functionality.
+ *
+ * @param options - Action execution parameters and API configuration options
+ * @returns Promise<ActionExecutionResult>
+ */
+async function runAction(options) {
+    const { app, type, action, inputs, authId: providedAuthId, token } = options;
+    if (!token && !process.env.ZAPIER_TOKEN) {
+        throw new Error("Authentication token is required to run actions. Please provide token in options or set ZAPIER_TOKEN environment variable.");
+    }
+    const api = (0, api_1.getOrCreateApiClient)(options);
+    // Validate that the action exists
+    const actionData = await (0, getAction_1.getAction)({
+        ...options,
+        app: app,
+        action: action,
+        type: type,
+    });
+    // Validate action type matches
+    if (actionData.type !== type) {
+        throw new Error(`Action type mismatch: expected ${type}, got ${actionData.type}`);
+    }
+    // Execute the action using the appropriate API based on action type
+    const startTime = Date.now();
+    const result = await executeActionWithStrategy({
+        api,
+        appSlug: app,
+        actionKey: action,
+        actionType: actionData.type,
+        executionOptions: { inputs: inputs || {} },
+        auth: token
+            ? { token: token, authentication_id: providedAuthId }
+            : undefined,
+        options,
+    });
+    const executionTime = Date.now() - startTime;
+    return {
+        success: true,
+        data: result,
+        metadata: {
+            executionTime,
+            requestId: (0, api_1.generateRequestId)(),
+        },
+    };
+}
+async function executeActionWithStrategy(strategyOptions) {
+    const { api, appSlug, actionKey, actionType, executionOptions, auth, options, } = strategyOptions;
+    // Actions API supports: read, read_bulk, write
+    // Invoke API supports: search, read, write, read_bulk, and more
+    const actionsApiTypes = ["read", "read_bulk", "write"];
+    const useActionsApi = actionsApiTypes.includes(actionType);
+    if (useActionsApi) {
+        return executeActionViaActionsApi({
+            api,
+            appSlug,
+            actionKey,
+            actionType,
+            executionOptions,
+            auth,
+            options,
+        });
+    }
+    else {
+        return executeActionViaInvokeApi({
+            api,
+            appSlug,
+            actionKey,
+            actionType,
+            executionOptions,
+            auth,
+            options,
+        });
+    }
+}
+async function executeActionViaActionsApi(apiOptions) {
+    const { api, appSlug, actionKey, actionType, executionOptions, auth, options, } = apiOptions;
+    // Use the standalone getApp function
+    const appData = await (0, getApp_1.getApp)({
+        key: appSlug,
+        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");
+    }
+    if (!auth?.token) {
+        throw new Error("Authentication token is required. Please provide token when creating the SDK.");
+    }
+    // Step 1: POST to /actions/v1/runs to start execution
+    const runRequest = {
+        data: {
+            authentication_id: auth.authentication_id || 1,
+            selected_api: selectedApi,
+            action_key: actionKey,
+            action_type: actionType,
+            inputs: executionOptions.inputs || {},
+        },
+    };
+    const runData = await api.post("/api/actions/v1/runs", runRequest);
+    const runId = runData.data.id;
+    // Step 2: Poll GET /actions/v1/runs/{run_id} for results
+    return await api.poll(`/api/actions/v1/runs/${runId}`, {
+        successStatus: 200,
+        pendingStatus: 202,
+        resultExtractor: (result) => result.data,
+    });
+}
+async function executeActionViaInvokeApi(apiOptions) {
+    const { api, appSlug, actionKey, actionType, executionOptions, auth, options, } = apiOptions;
+    // Use the standalone getApp function
+    const appData = await (0, getApp_1.getApp)({
+        key: appSlug,
+        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");
+    }
+    if (!auth?.token) {
+        throw new Error("Authentication token is required. Please provide token when creating the SDK.");
+    }
+    // Step 1: POST to /invoke/v1/invoke to start execution
+    const invokeRequest = {
+        selected_api: selectedApi,
+        action: actionKey,
+        type_of: actionType,
+        authentication_id: auth.authentication_id || 1,
+        params: executionOptions.inputs || {},
+    };
+    const invokeData = await api.post("/api/invoke/v1/invoke", invokeRequest);
+    const invocationId = invokeData.invocation_id;
+    // Step 2: Poll GET /invoke/v1/invoke/{invocation_id} for results
+    return await api.poll(`/api/invoke/v1/invoke/${invocationId}`, {
+        successStatus: 200,
+        pendingStatus: 202,
+        resultExtractor: (result) => result.results || result,
+    });
+}

package/dist/index.d.ts

@@ -1,3 +1,12 @@
-export * from "../../shared-sdk/dist";
-export * from "../../actions-sdk/dist";
-export { createZapierSDK, ZapierSDK, ZapierSDKOptions } from "./sdk";
+export * from "./types";
+export * from "./actions-sdk";
+export { listAuths } from "./functions/listAuths";
+export { listApps } from "./functions/listApps";
+export { getApp } from "./functions/getApp";
+export { listActions } from "./functions/listActions";
+export { getAction } from "./functions/getAction";
+export { runAction } from "./functions/runAction";
+export { listFields } from "./functions/listFields";
+export { generateTypes } from "./functions/generateTypes";
+export { bundleCode } from "./functions/bundleCode";
+export { createZapierSdk, ZapierSdk, ZapierSdkOptions } from "./sdk";

package/dist/index.js

@@ -14,10 +14,29 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createZapierSDK = void 0;
-// Export everything from shared and actions
-__exportStar(require("../../shared-sdk/dist"), exports);
-__exportStar(require("../../actions-sdk/dist"), exports);
+exports.createZapierSdk = exports.bundleCode = exports.generateTypes = exports.listFields = exports.runAction = exports.getAction = exports.listActions = exports.getApp = exports.listApps = exports.listAuths = void 0;
+// Export everything from types and actions-sdk
+__exportStar(require("./types"), exports);
+__exportStar(require("./actions-sdk"), exports);
+// Export individual functions for tree-shaking
+var listAuths_1 = require("./functions/listAuths");
+Object.defineProperty(exports, "listAuths", { enumerable: true, get: function () { return listAuths_1.listAuths; } });
+var listApps_1 = require("./functions/listApps");
+Object.defineProperty(exports, "listApps", { enumerable: true, get: function () { return listApps_1.listApps; } });
+var getApp_1 = require("./functions/getApp");
+Object.defineProperty(exports, "getApp", { enumerable: true, get: function () { return getApp_1.getApp; } });
+var listActions_1 = require("./functions/listActions");
+Object.defineProperty(exports, "listActions", { enumerable: true, get: function () { return listActions_1.listActions; } });
+var getAction_1 = require("./functions/getAction");
+Object.defineProperty(exports, "getAction", { enumerable: true, get: function () { return getAction_1.getAction; } });
+var runAction_1 = require("./functions/runAction");
+Object.defineProperty(exports, "runAction", { enumerable: true, get: function () { return runAction_1.runAction; } });
+var listFields_1 = require("./functions/listFields");
+Object.defineProperty(exports, "listFields", { enumerable: true, get: function () { return listFields_1.listFields; } });
+var generateTypes_1 = require("./functions/generateTypes");
+Object.defineProperty(exports, "generateTypes", { enumerable: true, get: function () { return generateTypes_1.generateTypes; } });
+var bundleCode_1 = require("./functions/bundleCode");
+Object.defineProperty(exports, "bundleCode", { enumerable: true, get: function () { return bundleCode_1.bundleCode; } });
 // Export the main combined SDK
 var sdk_1 = require("./sdk");
-Object.defineProperty(exports, "createZapierSDK", { enumerable: true, get: function () { return sdk_1.createZapierSDK; } });
+Object.defineProperty(exports, "createZapierSdk", { enumerable: true, get: function () { return sdk_1.createZapierSdk; } });

package/dist/output-schemas.d.ts

@@ -0,0 +1,95 @@
+import { z } from "zod";
+export interface FormattedItem {
+    title: string;
+    subtitle?: string;
+    details: Array<{
+        text: string;
+        style: "normal" | "dim" | "accent" | "warning" | "success";
+    }>;
+}
+export interface FormatMetadata {
+    format: (item: any) => FormattedItem;
+}
+export declare function withOutputSchema<T extends z.ZodType>(inputSchema: T, outputSchema: z.ZodType): T;
+export declare function getFormatMetadata(schema: z.ZodType): FormatMetadata | undefined;
+export declare function getOutputSchema(inputSchema: z.ZodType): z.ZodType | undefined;
+export declare const AppItemSchema: z.ZodObject<{
+    key: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    category: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    key: string;
+    name?: string | undefined;
+    description?: string | undefined;
+    category?: string | undefined;
+}, {
+    key: string;
+    name?: string | undefined;
+    description?: string | undefined;
+    category?: string | undefined;
+}>;
+export declare const ActionItemSchema: z.ZodObject<{
+    key: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    type: z.ZodString;
+    appKey: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    key: string;
+    type: string;
+    name?: string | undefined;
+    description?: string | undefined;
+    appKey?: string | undefined;
+}, {
+    key: string;
+    type: string;
+    name?: string | undefined;
+    description?: string | undefined;
+    appKey?: string | undefined;
+}>;
+export declare const AuthItemSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    title: z.ZodOptional<z.ZodString>;
+    label: z.ZodOptional<z.ZodString>;
+    identifier: z.ZodOptional<z.ZodString>;
+    account_id: z.ZodOptional<z.ZodString>;
+    is_private: z.ZodOptional<z.ZodBoolean>;
+    shared_with_all: z.ZodOptional<z.ZodBoolean>;
+    marked_stale_at: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: number;
+    account_id?: string | undefined;
+    title?: string | undefined;
+    label?: string | undefined;
+    identifier?: string | undefined;
+    is_private?: boolean | undefined;
+    shared_with_all?: boolean | undefined;
+    marked_stale_at?: string | undefined;
+}, {
+    id: number;
+    account_id?: string | undefined;
+    title?: string | undefined;
+    label?: string | undefined;
+    identifier?: string | undefined;
+    is_private?: boolean | undefined;
+    shared_with_all?: boolean | undefined;
+    marked_stale_at?: string | undefined;
+}>;
+export declare const FieldItemSchema: z.ZodObject<{
+    key: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    key: string;
+    name?: string | undefined;
+    description?: string | undefined;
+}, {
+    key: string;
+    name?: string | undefined;
+    description?: string | undefined;
+}>;
+export type AppItem = z.infer<typeof AppItemSchema>;
+export type ActionItem = z.infer<typeof ActionItemSchema>;
+export type AuthItem = z.infer<typeof AuthItemSchema>;
+export type FieldItem = z.infer<typeof FieldItemSchema>;

package/dist/output-schemas.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldItemSchema = exports.AuthItemSchema = exports.ActionItemSchema = exports.AppItemSchema = void 0;
+exports.withOutputSchema = withOutputSchema;
+exports.getFormatMetadata = getFormatMetadata;
+exports.getOutputSchema = getOutputSchema;
+const zod_1 = require("zod");
+// ============================================================================
+// Schema Enhancement Helpers
+// ============================================================================
+// Helper function to add format metadata to schemas
+function withFormatter(schema, formatMeta) {
+    // Store format metadata on the schema definition
+    schema._def.formatMeta = formatMeta;
+    return schema;
+}
+// Helper function to link input schemas to output schemas
+function withOutputSchema(inputSchema, outputSchema) {
+    // Store output schema reference on the input schema
+    inputSchema._def.outputSchema = outputSchema;
+    return inputSchema;
+}
+// Helper function to get format metadata from a schema
+function getFormatMetadata(schema) {
+    return schema._def.formatMeta;
+}
+// Helper function to get output schema from an input schema
+function getOutputSchema(inputSchema) {
+    return inputSchema._def.outputSchema;
+}
+// ============================================================================
+// Output Item Schemas
+// ============================================================================
+exports.AppItemSchema = withFormatter(zod_1.z.object({
+    key: zod_1.z.string(),
+    name: zod_1.z.string().optional(),
+    description: zod_1.z.string().optional(),
+    category: zod_1.z.string().optional(),
+}), {
+    format: (item) => {
+        const details = [];
+        if (item.description) {
+            details.push({ text: item.description, style: "dim" });
+        }
+        if (item.category) {
+            details.push({
+                text: `Category: ${item.category}`,
+                style: "accent",
+            });
+        }
+        return {
+            title: item.name || item.key,
+            subtitle: `(${item.key})`,
+            details,
+        };
+    },
+});
+exports.ActionItemSchema = withFormatter(zod_1.z.object({
+    key: zod_1.z.string(),
+    name: zod_1.z.string().optional(),
+    type: zod_1.z.string(),
+    appKey: zod_1.z.string().optional(),
+    description: zod_1.z.string().optional(),
+}), {
+    format: (item) => {
+        const details = [];
+        details.push({ text: `Type: ${item.type}`, style: "accent" });
+        if (item.appKey) {
+            details.push({ text: `App: ${item.appKey}`, style: "normal" });
+        }
+        if (item.description) {
+            details.push({ text: item.description, style: "dim" });
+        }
+        return {
+            title: item.name || item.key,
+            subtitle: `(${item.key})`,
+            details,
+        };
+    },
+});
+exports.AuthItemSchema = withFormatter(zod_1.z.object({
+    id: zod_1.z.number(),
+    title: zod_1.z.string().optional(),
+    label: zod_1.z.string().optional(),
+    identifier: zod_1.z.string().optional(),
+    account_id: zod_1.z.string().optional(),
+    is_private: zod_1.z.boolean().optional(),
+    shared_with_all: zod_1.z.boolean().optional(),
+    marked_stale_at: zod_1.z.string().optional(),
+}), {
+    format: (item) => {
+        const details = [];
+        if (item.identifier) {
+            details.push({
+                text: `Identifier: ${item.identifier}`,
+                style: "accent",
+            });
+        }
+        if (item.label && item.title && item.label !== item.title) {
+            details.push({
+                text: `Label: ${item.label}`,
+                style: "normal",
+            });
+        }
+        details.push({
+            text: `Account: ${item.account_id || "unknown"} | Private: ${item.is_private || false} | Shared: ${item.shared_with_all || false}`,
+            style: "dim",
+        });
+        if (item.marked_stale_at) {
+            details.push({
+                text: `⚠️  Marked stale: ${new Date(item.marked_stale_at).toLocaleDateString()}`,
+                style: "warning",
+            });
+        }
+        return {
+            title: item.title || item.label || `Authentication ${item.id}`,
+            subtitle: `(ID: ${item.id})`,
+            details,
+        };
+    },
+});
+exports.FieldItemSchema = withFormatter(zod_1.z.object({
+    key: zod_1.z.string(),
+    name: zod_1.z.string().optional(),
+    description: zod_1.z.string().optional(),
+}), {
+    format: (item) => {
+        const details = [];
+        if (item.description) {
+            details.push({ text: item.description, style: "dim" });
+        }
+        return {
+            title: item.name || item.key,
+            subtitle: `(${item.key})`,
+            details,
+        };
+    },
+});