@zapier/zapier-sdk 0.0.2 → 0.0.3

package/dist/api.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Zapier API Client Module
+ *
+ * This module provides a centralized API layer for all HTTP interactions
+ * with Zapier's various APIs. It handles authentication, error handling,
+ * polling, and provides consistent patterns across all services.
+ */
+export interface ApiClientOptions {
+    baseUrl: string;
+    token?: string;
+    debug?: boolean;
+    fetch?: typeof globalThis.fetch;
+}
+export interface ApiClient {
+    get: (path: string, options?: RequestOptions) => Promise<any>;
+    post: (path: string, data?: any, options?: RequestOptions) => Promise<any>;
+    put: (path: string, data?: any, options?: RequestOptions) => Promise<any>;
+    delete: (path: string, options?: RequestOptions) => Promise<any>;
+    poll: (path: string, options?: PollOptions) => Promise<any>;
+}
+export interface RequestOptions {
+    headers?: Record<string, string>;
+    searchParams?: Record<string, string>;
+    authRequired?: boolean;
+    customErrorHandler?: (response: Response) => Error | undefined;
+}
+export interface PollOptions extends RequestOptions {
+    maxAttempts?: number;
+    initialDelay?: number;
+    maxDelay?: number;
+    successStatus?: number;
+    pendingStatus?: number;
+    resultExtractor?: (response: any) => any;
+}
+export declare function isJwt(token: string): boolean;
+export declare function getAuthorizationHeader(token: string): string;
+export declare function pollUntilComplete(options: {
+    fetch: typeof globalThis.fetch;
+    url: string;
+    headers?: Record<string, string>;
+    maxAttempts?: number;
+    initialDelay?: number;
+    maxDelay?: number;
+    successStatus?: number;
+    pendingStatus?: number;
+    resultExtractor?: (response: any) => any;
+}): Promise<any>;
+export declare function createZapierApi(options: ApiClientOptions): ApiClient;
+export declare function generateRequestId(): string;
+/**
+ * Utility function to get or create an API client for standalone functions
+ *
+ * @param config - Configuration that may include an existing API client
+ * @returns ApiClient instance
+ */
+export declare function getOrCreateApiClient(config: {
+    baseUrl?: string;
+    token?: string;
+    api?: ApiClient;
+    debug?: boolean;
+    fetch?: typeof globalThis.fetch;
+}): ApiClient;

package/dist/api.js

@@ -0,0 +1,227 @@
+"use strict";
+/**
+ * Zapier API Client Module
+ *
+ * This module provides a centralized API layer for all HTTP interactions
+ * with Zapier's various APIs. It handles authentication, error handling,
+ * polling, and provides consistent patterns across all services.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isJwt = isJwt;
+exports.getAuthorizationHeader = getAuthorizationHeader;
+exports.pollUntilComplete = pollUntilComplete;
+exports.createZapierApi = createZapierApi;
+exports.generateRequestId = generateRequestId;
+exports.getOrCreateApiClient = getOrCreateApiClient;
+// ============================================================================
+// Authentication Utilities
+// ============================================================================
+function isJwt(token) {
+    // JWT tokens have exactly 3 parts separated by dots
+    const parts = token.split(".");
+    if (parts.length !== 3) {
+        return false;
+    }
+    // Each part should be base64url encoded (no padding)
+    // Basic validation - each part should be non-empty and contain valid base64url characters
+    const base64UrlPattern = /^[A-Za-z0-9_-]+$/;
+    return parts.every((part) => part.length > 0 && base64UrlPattern.test(part));
+}
+function getAuthorizationHeader(token) {
+    // Check if token is a JWT (has 3 parts separated by dots)
+    if (isJwt(token)) {
+        return `JWT ${token}`;
+    }
+    // Default to Bearer for other token types
+    return `Bearer ${token}`;
+}
+// ============================================================================
+// Debug Logging
+// ============================================================================
+function createDebugLogger(enabled) {
+    if (!enabled) {
+        return () => { }; // No-op function when debug is disabled
+    }
+    return (message, data) => {
+        console.log(`[Zapier SDK] ${message}`, data || "");
+    };
+}
+function createDebugFetch(options) {
+    const { originalFetch, debugLog } = options;
+    return async (input, options) => {
+        const startTime = Date.now();
+        // Convert input to URL string for logging
+        const url = typeof input === "string" ? input : input.toString();
+        const method = options?.method || "GET";
+        debugLog(`→ ${method} ${url}`, {
+            headers: options?.headers,
+            body: options?.body ? JSON.parse(options.body) : undefined,
+        });
+        try {
+            const response = await originalFetch(input, options);
+            const duration = Date.now() - startTime;
+            debugLog(`← ${response.status} ${response.statusText} (${duration}ms)`, {
+                url,
+                method,
+                status: response.status,
+            });
+            return response;
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            debugLog(`✖ Request failed (${duration}ms)`, {
+                url,
+                method,
+                error: error instanceof Error ? error.message : error,
+            });
+            throw error;
+        }
+    };
+}
+// ============================================================================
+// Polling Utilities
+// ============================================================================
+async function pollUntilComplete(options) {
+    const { fetch, url, headers = {}, maxAttempts = 30, initialDelay = 50, maxDelay = 1000, successStatus = 200, pendingStatus = 202, resultExtractor = (response) => response, } = options;
+    let delay = initialDelay;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        const response = await fetch(url, { headers });
+        if (response.status === successStatus) {
+            // Success - extract and return results
+            const result = await response.json();
+            return resultExtractor(result);
+        }
+        else if (response.status === pendingStatus) {
+            // Still processing - wait and retry
+            if (attempt < maxAttempts - 1) {
+                await new Promise((resolve) => setTimeout(resolve, delay));
+                delay = Math.min(delay * 2, maxDelay); // Exponential backoff
+                continue;
+            }
+        }
+        else {
+            // Error occurred
+            throw new Error(`Request failed: GET ${url} - ${response.status} ${response.statusText}`);
+        }
+    }
+    throw new Error(`Operation timed out after ${maxAttempts} attempts`);
+}
+// ============================================================================
+// API Client Factory
+// ============================================================================
+function createZapierApi(options) {
+    const { baseUrl, token, debug = false, fetch: originalFetch = globalThis.fetch, } = options;
+    const debugLog = createDebugLogger(debug);
+    const fetch = createDebugFetch({ originalFetch, debugLog });
+    // Helper to build full URLs
+    function buildUrl(path, searchParams) {
+        const url = new URL(path, baseUrl);
+        if (searchParams) {
+            Object.entries(searchParams).forEach(([key, value]) => {
+                url.searchParams.set(key, value);
+            });
+        }
+        return url.toString();
+    }
+    // Helper to build headers
+    function buildHeaders(options = {}) {
+        const headers = {
+            ...options.headers,
+        };
+        // Add auth header if token provided and not explicitly disabled
+        if (token && options.authRequired !== false) {
+            headers.Authorization = getAuthorizationHeader(token);
+        }
+        return headers;
+    }
+    // Helper to handle responses
+    async function handleResponse(response, customErrorHandler) {
+        if (!response.ok) {
+            // Check for custom error handling first
+            if (customErrorHandler) {
+                const customError = customErrorHandler(response);
+                if (customError) {
+                    throw customError;
+                }
+            }
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        // Try to parse JSON, fall back to text if that fails
+        try {
+            return await response.json();
+        }
+        catch {
+            return await response.text();
+        }
+    }
+    // Helper to perform HTTP requests with JSON handling
+    async function fetchJson(method, path, data, options = {}) {
+        const url = buildUrl(path, options.searchParams);
+        const headers = buildHeaders(options);
+        // Add Content-Type for JSON requests with body data
+        if (data && typeof data === "object") {
+            headers["Content-Type"] = "application/json";
+        }
+        const response = await fetch(url, {
+            method,
+            headers,
+            body: data ? JSON.stringify(data) : undefined,
+        });
+        return handleResponse(response, options.customErrorHandler);
+    }
+    return {
+        async get(path, options = {}) {
+            return fetchJson("GET", path, undefined, options);
+        },
+        async post(path, data, options = {}) {
+            return fetchJson("POST", path, data, options);
+        },
+        async put(path, data, options = {}) {
+            return fetchJson("PUT", path, data, options);
+        },
+        async delete(path, options = {}) {
+            return fetchJson("DELETE", path, undefined, options);
+        },
+        async poll(path, options = {}) {
+            const url = buildUrl(path, options.searchParams);
+            const headers = buildHeaders(options);
+            return pollUntilComplete({
+                fetch,
+                url,
+                headers,
+                maxAttempts: options.maxAttempts,
+                initialDelay: options.initialDelay,
+                maxDelay: options.maxDelay,
+                successStatus: options.successStatus,
+                pendingStatus: options.pendingStatus,
+                resultExtractor: options.resultExtractor,
+            });
+        },
+    };
+}
+// ============================================================================
+// Utility Functions
+// ============================================================================
+function generateRequestId() {
+    return Math.random().toString(36).substring(2) + Date.now().toString(36);
+}
+// ============================================================================
+// Utility Functions for Standalone Functions
+// ============================================================================
+/**
+ * Utility function to get or create an API client for standalone functions
+ *
+ * @param config - Configuration that may include an existing API client
+ * @returns ApiClient instance
+ */
+function getOrCreateApiClient(config) {
+    const { baseUrl = "https://zapier.com", token = process.env.ZAPIER_TOKEN, api: providedApi, debug = false, fetch: customFetch, } = config;
+    // Use provided API client or create a new one
+    return (providedApi ||
+        createZapierApi({
+            baseUrl,
+            token,
+            debug,
+            fetch: customFetch,
+        }));
+}

package/dist/functions/bundleCode.d.ts

@@ -0,0 +1,18 @@
+export interface BundleCodeOptions {
+    input: string;
+    output?: string;
+    target?: string;
+    cjs?: boolean;
+    minify?: boolean;
+    string?: boolean;
+}
+/**
+ * Bundle TypeScript code into executable JavaScript
+ *
+ * This function can be used standalone without instantiating a full SDK,
+ * which enables better tree-shaking in applications that only need this functionality.
+ *
+ * @param options - Bundling configuration options
+ * @returns Promise<string> - Bundled JavaScript code
+ */
+export declare function bundleCode(options: BundleCodeOptions): Promise<string>;

package/dist/functions/bundleCode.js

@@ -0,0 +1,91 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bundleCode = bundleCode;
+/**
+ * Bundle TypeScript code into executable JavaScript
+ *
+ * This function can be used standalone without instantiating a full SDK,
+ * which enables better tree-shaking in applications that only need this functionality.
+ *
+ * @param options - Bundling configuration options
+ * @returns Promise<string> - Bundled JavaScript code
+ */
+async function bundleCode(options) {
+    const { input, output, target = "es2020", cjs = false, minify = false, string: returnString = false, } = options;
+    // Dynamically import esbuild
+    const { buildSync } = await Promise.resolve().then(() => __importStar(require("esbuild")));
+    const fs = await Promise.resolve().then(() => __importStar(require("fs")));
+    const path = await Promise.resolve().then(() => __importStar(require("path")));
+    // Resolve input path
+    const resolvedInput = path.resolve(process.cwd(), input);
+    try {
+        // Bundle with esbuild
+        const result = buildSync({
+            entryPoints: [resolvedInput],
+            bundle: true,
+            platform: "node",
+            target: target,
+            format: cjs ? "cjs" : "esm",
+            minify: minify,
+            write: false,
+            external: [], // Bundle everything
+            banner: {
+                js: "#!/usr/bin/env node",
+            },
+        });
+        if (result.errors.length > 0) {
+            throw new Error(`Bundle failed: ${result.errors.map((e) => e.text).join(", ")}`);
+        }
+        const bundledCode = result.outputFiles?.[0]?.text;
+        if (!bundledCode) {
+            throw new Error("No output generated");
+        }
+        let finalOutput = bundledCode;
+        if (returnString) {
+            // Output as quoted string for node -e using JSON.stringify
+            finalOutput = JSON.stringify(bundledCode);
+        }
+        // Write to file if output path specified
+        if (output) {
+            fs.mkdirSync(path.dirname(output), { recursive: true });
+            fs.writeFileSync(output, finalOutput, "utf8");
+        }
+        return finalOutput;
+    }
+    catch (error) {
+        throw new Error(`Bundle failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+}

package/dist/functions/generateTypes.d.ts

@@ -0,0 +1,16 @@
+import type { FunctionConfig } from "../types";
+export interface GenerateTypesOptions extends FunctionConfig {
+    appKey: string;
+    authId?: number;
+    output?: string;
+}
+/**
+ * Generate TypeScript types for a specific app
+ *
+ * This function can be used standalone without instantiating a full SDK,
+ * which enables better tree-shaking in applications that only need this functionality.
+ *
+ * @param options - App key, auth ID, output path, and API configuration options
+ * @returns Promise<string> - Generated TypeScript code
+ */
+export declare function generateTypes(options: GenerateTypesOptions): Promise<string>;

package/dist/functions/generateTypes.js

@@ -0,0 +1,271 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTypes = generateTypes;
+const listActions_1 = require("./listActions");
+const listFields_1 = require("./listFields");
+/**
+ * Generate TypeScript types for a specific app
+ *
+ * This function can be used standalone without instantiating a full SDK,
+ * which enables better tree-shaking in applications that only need this functionality.
+ *
+ * @param options - App key, auth ID, output path, and API configuration options
+ * @returns Promise<string> - Generated TypeScript code
+ */
+async function generateTypes(options) {
+    const { appKey, authId, output = `./types/${appKey}.d.ts` } = options;
+    // Parse app identifier (support app@version format)
+    const { app, version } = parseAppIdentifier(appKey);
+    // Fetch all actions for the app
+    const actions = await (0, listActions_1.listActions)({
+        ...options,
+        appKey: app,
+    });
+    if (actions.length === 0) {
+        const typeDefinitions = generateEmptyTypesFile(app, version);
+        if (output) {
+            const fs = await Promise.resolve().then(() => __importStar(require("fs")));
+            const path = await Promise.resolve().then(() => __importStar(require("path")));
+            fs.mkdirSync(path.dirname(output), { recursive: true });
+            fs.writeFileSync(output, typeDefinitions, "utf8");
+        }
+        return typeDefinitions;
+    }
+    // Fetch input fields for each action
+    const actionsWithFields = [];
+    if (authId) {
+        for (const action of actions) {
+            try {
+                const fields = await (0, listFields_1.listFields)({
+                    ...options,
+                    app: action.appKey,
+                    action: action.key,
+                    type: action.type,
+                    authId: authId,
+                });
+                actionsWithFields.push({ ...action, inputFields: fields });
+            }
+            catch {
+                // If we can't get fields for an action, include it without fields
+                actionsWithFields.push({ ...action, inputFields: [] });
+            }
+        }
+    }
+    else {
+        // Convert actions to have empty input fields (will generate generic types)
+        actions.forEach((action) => {
+            actionsWithFields.push({ ...action, inputFields: [] });
+        });
+    }
+    // Generate TypeScript types
+    const typeDefinitions = generateTypeDefinitions(app, actionsWithFields, version);
+    // Write to file if output path specified
+    if (output) {
+        const fs = await Promise.resolve().then(() => __importStar(require("fs")));
+        const path = await Promise.resolve().then(() => __importStar(require("path")));
+        fs.mkdirSync(path.dirname(output), { recursive: true });
+        fs.writeFileSync(output, typeDefinitions, "utf8");
+    }
+    return typeDefinitions;
+}
+function parseAppIdentifier(identifier) {
+    const parts = identifier.split("@");
+    return {
+        app: parts[0],
+        version: parts[1],
+    };
+}
+function generateTypeDefinitions(appKey, actions, version) {
+    // Handle empty actions
+    if (actions.length === 0) {
+        return generateEmptyTypesFile(appKey, version);
+    }
+    // Group actions by type
+    const actionsByType = actions.reduce((acc, action) => {
+        if (!acc[action.type]) {
+            acc[action.type] = [];
+        }
+        acc[action.type].push(action);
+        return acc;
+    }, {});
+    const appName = capitalize(appKey);
+    const versionComment = version
+        ? ` * Generated for ${appKey}@${version}`
+        : ` * Generated for ${appKey}`;
+    let output = `/* eslint-disable @typescript-eslint/naming-convention */
+/**
+ * Auto-generated TypeScript types for Zapier ${appKey} actions
+${versionComment}
+ * Generated on: ${new Date().toISOString()}
+ * 
+ * Usage:
+ *   import type { ${appName}Actions } from './path/to/this/file'
+ *   const sdk: ActionsSdk & { actions: ${appName}Actions } = createActionsSdk(...)
+ */
+
+import type { ActionExecutionOptions, ActionExecutionResult } from '@zapier/zapier-sdk'
+
+`;
+    // Generate input types for each action
+    actions.forEach((action) => {
+        if (action.inputFields.length > 0) {
+            const inputTypeName = `${appName}${capitalize(action.type)}${capitalize(sanitizeActionName(action.key))}Inputs`;
+            output += `interface ${inputTypeName} {\n`;
+            action.inputFields.forEach((field) => {
+                const isOptional = !field.required;
+                const fieldType = mapFieldTypeToTypeScript(field);
+                const description = field.helpText
+                    ? `  /** ${escapeComment(field.helpText)} */\n`
+                    : "";
+                output += `${description}  ${sanitizeFieldName(field.key)}${isOptional ? "?" : ""}: ${fieldType}\n`;
+            });
+            output += `}\n\n`;
+        }
+    });
+    // Generate action type interfaces for each action type
+    Object.entries(actionsByType).forEach(([actionType, typeActions]) => {
+        const typeName = `${appName}${capitalize(actionType)}Actions`;
+        output += `interface ${typeName} {\n`;
+        typeActions.forEach((action) => {
+            const actionName = sanitizeActionName(action.key);
+            const description = action.description
+                ? `  /** ${escapeComment(action.description)} */\n`
+                : "";
+            // Generate type-safe action method signature
+            if (action.inputFields.length > 0) {
+                const inputTypeName = `${appName}${capitalize(action.type)}${capitalize(sanitizeActionName(action.key))}Inputs`;
+                output += `${description}  ${actionName}: (options: { inputs: ${inputTypeName} } & Omit<ActionExecutionOptions, 'inputs'>) => Promise<ActionExecutionResult>\n`;
+            }
+            else {
+                // No specific input fields available - use generic Record<string, any> for inputs
+                output += `${description}  ${actionName}: (options?: { inputs?: Record<string, any> } & ActionExecutionOptions) => Promise<ActionExecutionResult>\n`;
+            }
+        });
+        output += `}\n\n`;
+    });
+    // Generate the main app actions interface
+    output += `export interface ${appName}Actions {\n`;
+    output += `  run: {\n`;
+    output += `    ${appKey}: {\n`;
+    Object.keys(actionsByType).forEach((actionType) => {
+        const typeName = `${appName}${capitalize(actionType)}Actions`;
+        output += `      ${actionType}: ${typeName}\n`;
+    });
+    output += `    }\n`;
+    output += `  }\n`;
+    output += `}\n`;
+    return output;
+}
+function generateEmptyTypesFile(appKey, version) {
+    const appName = capitalize(appKey);
+    const versionComment = version
+        ? ` * Generated for ${appKey}@${version}`
+        : ` * Generated for ${appKey}`;
+    return `/* eslint-disable @typescript-eslint/naming-convention */
+/**
+ * Auto-generated TypeScript types for Zapier ${appKey} actions
+${versionComment}
+ * Generated on: ${new Date().toISOString()}
+ * 
+ * No actions found for this app.
+ */
+
+import type { ActionExecutionOptions, ActionExecutionResult } from '@zapier/zapier-sdk'
+
+export interface ${appName}Actions {
+  run: {
+    ${appKey}: {
+      // No actions available
+    }
+  }
+}
+`;
+}
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1).replace(/[-_]/g, "");
+}
+function sanitizeActionName(actionKey) {
+    // Ensure the action name is a valid TypeScript identifier
+    return actionKey.replace(/[^a-zA-Z0-9_$]/g, "_");
+}
+function sanitizeFieldName(fieldKey) {
+    // Ensure the field name is a valid TypeScript identifier
+    return fieldKey.replace(/[^a-zA-Z0-9_$]/g, "_");
+}
+function escapeComment(comment) {
+    // Escape comment text to prevent breaking the JSDoc comment
+    return comment.replace(/\*\//g, "*\\/").replace(/\r?\n/g, " ");
+}
+function mapFieldTypeToTypeScript(field) {
+    // Handle choices (enum-like fields)
+    if (field.choices && field.choices.length > 0) {
+        const choiceValues = field.choices
+            .filter((choice) => choice.value !== undefined &&
+            choice.value !== null &&
+            choice.value !== "")
+            .map((choice) => typeof choice.value === "string" ? `"${choice.value}"` : choice.value);
+        if (choiceValues.length > 0) {
+            return choiceValues.join(" | ");
+        }
+        // If all choices were filtered out, fall through to default type handling
+    }
+    // Map Zapier field types to TypeScript types
+    switch (field.type?.toLowerCase()) {
+        case "string":
+        case "text":
+        case "email":
+        case "url":
+        case "password":
+            return "string";
+        case "integer":
+        case "number":
+            return "number";
+        case "boolean":
+            return "boolean";
+        case "datetime":
+        case "date":
+            return "string"; // ISO date strings
+        case "file":
+            return "string"; // File URL or content
+        case "array":
+            return "any[]";
+        case "object":
+            return "Record<string, any>";
+        default:
+            // Default to string for unknown types, with union for common cases
+            return "string | number | boolean";
+    }
+}