@zapier/zapier-sdk-cli 0.4.4 → 0.6.0

package/dist/cli.js

@@ -205,29 +205,38 @@ var SchemaParameterResolver = class {
     }
     console.log(chalk.blue(`
 \u{1F50D} Resolving ${param.name}...`));
-    if (resolver.type === "static") {
+    const typedResolver = resolver;
+    if (typedResolver.type === "static") {
       const promptConfig = {
-        type: resolver.inputType === "password" ? "password" : "input",
+        type: typedResolver.inputType === "password" ? "password" : "input",
         name: param.name,
         message: `Enter ${param.name}:`,
-        ...resolver.placeholder && { default: resolver.placeholder }
+        ...typedResolver.placeholder && {
+          default: typedResolver.placeholder
+        }
       };
       const answers = await inquirer.prompt([promptConfig]);
       return answers[param.name];
-    } else if (resolver.type === "dynamic") {
+    } else if (typedResolver.type === "dynamic") {
       try {
         if (param.isRequired && param.name !== "authenticationId") {
           console.log(chalk.gray(`Fetching options for ${param.name}...`));
         }
-        const items = await resolver.fetch(context.sdk, context.resolvedParams);
+        const items = await typedResolver.fetch(
+          context.sdk,
+          context.resolvedParams
+        );
         const safeItems = items || [];
-        const promptConfig = resolver.prompt(safeItems, context.resolvedParams);
+        const promptConfig = typedResolver.prompt(
+          safeItems,
+          context.resolvedParams
+        );
         const answers = await inquirer.prompt([promptConfig]);
         return answers[param.name];
       } catch (error) {
         throw error;
       }
-    } else if (resolver.type === "fields") {
+    } else if (typedResolver.type === "fields") {
       return await this.resolveFieldsRecursively(
         resolver,
         context,
@@ -237,6 +246,7 @@ var SchemaParameterResolver = class {
     throw new Error(`Unknown resolver type for ${param.name}`);
   }
   async resolveFieldsRecursively(resolver, context, param) {
+    const typedResolver = resolver;
     const inputs = {};
     let processedFieldKeys = /* @__PURE__ */ new Set();
     let iteration = 0;
@@ -255,7 +265,7 @@ var SchemaParameterResolver = class {
           `Fetching input fields for ${param.name}${iteration > 1 ? ` (iteration ${iteration})` : ""}...`
         )
       );
-      const fields = await resolver.fetch(
+      const fields = await typedResolver.fetch(
         updatedContext.sdk,
         updatedContext.resolvedParams
       );
@@ -268,7 +278,7 @@ var SchemaParameterResolver = class {
         break;
       }
       const newFields = fields.filter(
-        (field) => !processedFieldKeys.has(field.key)
+        (field) => !(field.key && processedFieldKeys.has(field.key))
       );
       if (newFields.length === 0) {
         break;
@@ -343,40 +353,54 @@ Optional fields:`));
     return inputs;
   }
   getNestedValue(obj, path3) {
-    return path3.reduce((current, key) => current?.[key], obj);
+    return path3.reduce(
+      (current, key) => current?.[key],
+      obj
+    );
   }
   setNestedValue(obj, path3, value) {
     const lastKey = path3[path3.length - 1];
     const parent = path3.slice(0, -1).reduce((current, key) => {
-      if (!(key in current)) {
-        current[key] = {};
+      const currentObj = current;
+      if (!(key in currentObj)) {
+        currentObj[key] = {};
       }
-      return current[key];
+      return currentObj[key];
     }, obj);
     parent[lastKey] = value;
   }
   async promptForField(field, inputs) {
+    const fieldObj = field;
     const fieldPrompt = {
-      type: field.type === "boolean" ? "confirm" : "input",
-      name: field.key,
-      message: `${field.label || field.key}${field.required ? " (required)" : " (optional)"}:`,
-      ...field.helpText && { prefix: chalk.gray(`\u2139 ${field.helpText}
-`) },
-      ...field.default && { default: field.default }
+      type: fieldObj.type === "boolean" ? "confirm" : "input",
+      name: fieldObj.key,
+      message: `${fieldObj.label || fieldObj.key}${fieldObj.required ? " (required)" : " (optional)"}:`
     };
-    if (field.choices && field.choices.length > 0) {
+    if (fieldObj.helpText) {
+      fieldPrompt.prefix = chalk.gray(`\u2139 ${fieldObj.helpText}
+`);
+    }
+    if (fieldObj.default !== void 0) {
+      fieldPrompt.default = fieldObj.default;
+    }
+    if (fieldObj.choices && fieldObj.choices.length > 0) {
       fieldPrompt.type = "list";
-      fieldPrompt.choices = field.choices.map((choice) => ({
-        name: choice.label || choice.value,
-        value: choice.value
-      }));
+      fieldPrompt.choices = fieldObj.choices.map(
+        (choice) => {
+          const choiceObj = choice;
+          return {
+            name: choiceObj.label || choiceObj.value,
+            value: choiceObj.value
+          };
+        }
+      );
     }
     try {
       const answer = await inquirer.prompt([fieldPrompt]);
-      if (answer[field.key] !== void 0 && answer[field.key] !== "") {
-        inputs[field.key] = answer[field.key];
-      } else if (field.required) {
-        throw new Error(`Required field ${field.key} cannot be empty`);
+      if (answer[fieldObj.key] !== void 0 && answer[fieldObj.key] !== "") {
+        inputs[fieldObj.key] = answer[fieldObj.key];
+      } else if (fieldObj.required) {
+        throw new Error(`Required field ${fieldObj.key} cannot be empty`);
       }
     } catch (error) {
       if (this.isUserCancellation(error)) {
@@ -387,7 +411,8 @@ Optional fields:`));
     }
   }
   isUserCancellation(error) {
-    return error?.name === "ExitPromptError" || error?.message?.includes("User force closed") || error?.isTTYError;
+    const errorObj = error;
+    return errorObj?.name === "ExitPromptError" || errorObj?.message?.includes("User force closed") || errorObj?.isTTYError === true;
   }
 };
 
@@ -444,10 +469,11 @@ function applyStyle(value, style) {
 }
 function formatItemsGeneric(items) {
   items.forEach((item, index) => {
-    const name = item.title || item.name || item.key || item.id || "Item";
+    const itemObj = item;
+    const name = itemObj.title || itemObj.name || itemObj.key || itemObj.id || "Item";
     console.log(`${chalk2.gray(`${index + 1}.`)} ${chalk2.cyan(name)}`);
-    if (item.description) {
-      console.log(`   ${chalk2.dim(item.description)}`);
+    if (itemObj.description) {
+      console.log(`   ${chalk2.dim(itemObj.description)}`);
     }
     console.log();
   });
@@ -525,11 +551,12 @@ function methodNameToCliCommand(methodName) {
   return toKebabCase(methodName);
 }
 function generateCliCommands(program2, sdk2) {
-  if (!sdk2.__registry) {
+  if (typeof sdk2.getRegistry !== "function") {
     console.error("SDK registry not available");
     return;
   }
-  sdk2.__registry.forEach((fnInfo) => {
+  const registry = sdk2.getRegistry();
+  registry.functions.forEach((fnInfo) => {
     if (!fnInfo.inputSchema) {
       console.warn(`Schema not found for ${fnInfo.name}`);
       return;
@@ -543,6 +570,66 @@ function generateCliCommands(program2, sdk2) {
     );
     addCommand(program2, cliCommandName, config);
   });
+  program2.configureHelp({
+    formatHelp: (cmd, helper) => {
+      const helpWidth = helper.helpWidth || 80;
+      let output = helper.commandUsage(cmd) + "\n";
+      if (cmd.description()) {
+        output += helper.wrap(cmd.description(), helpWidth, 0) + "\n";
+      }
+      const options = helper.visibleOptions(cmd);
+      if (options.length > 0) {
+        output += "\nOptions:\n";
+        const longestOptionLength = Math.max(
+          ...options.map((opt) => helper.optionTerm(opt).length)
+        );
+        options.forEach((option) => {
+          const term = helper.optionTerm(option);
+          const padding = " ".repeat(
+            Math.max(2, longestOptionLength - term.length + 4)
+          );
+          output += `  ${term}${padding}${helper.optionDescription(option)}
+`;
+        });
+      }
+      const commands = helper.visibleCommands(cmd);
+      if (commands.length > 0) {
+        output += "\nCommands:\n";
+        const categorizedCommands = /* @__PURE__ */ new Set();
+        registry.categories.forEach((category) => {
+          const categoryCommands = commands.filter(
+            (command) => category.functions.some((functionName) => {
+              const cliCommandName = methodNameToCliCommand(functionName);
+              return command.name() === cliCommandName;
+            })
+          );
+          if (categoryCommands.length > 0) {
+            output += `
+  ${category.titlePlural}:
+`;
+            categoryCommands.forEach((command) => {
+              output += `    ${helper.subcommandTerm(command)}
+`;
+              categorizedCommands.add(command.name());
+            });
+          }
+        });
+        const otherCommands = commands.filter(
+          (command) => !categorizedCommands.has(command.name())
+        );
+        if (otherCommands.length > 0) {
+          output += `
+  Other:
+`;
+          otherCommands.forEach((command) => {
+            output += `    ${helper.subcommandTerm(command)}
+`;
+          });
+        }
+      }
+      return output;
+    }
+  });
 }
 function createCommandConfig(cliCommandName, sdkMethodName, schema, sdk2) {
   const parameters = analyzeZodSchema(schema);
@@ -568,24 +655,27 @@ function createCommandConfig(cliCommandName, sdkMethodName, schema, sdk2) {
         rawParams,
         sdk2
       );
-      const hasOutputFile = resolvedParams.output;
-      if (hasOutputFile) {
-        await sdk2[sdkMethodName](resolvedParams);
-        console.log(
-          chalk3.green(`\u2705 ${cliCommandName} completed successfully!`)
-        );
-        console.log(chalk3.gray(`Output written to: ${resolvedParams.output}`));
-        return;
-      }
       if (isListCommand && hasPaginationParams && !shouldUseJson && !hasUserSpecifiedMaxItems) {
-        const sdkIterator = sdk2[sdkMethodName](resolvedParams);
+        const sdkObj = sdk2;
+        const sdkIterator = await sdkObj[sdkMethodName](resolvedParams);
         await handlePaginatedListWithAsyncIteration(
           sdkMethodName,
           sdkIterator,
           schema
         );
       } else {
-        const result = await sdk2[sdkMethodName](resolvedParams);
+        const hasOutputFile = resolvedParams.output;
+        if (hasOutputFile) {
+          const sdkObj2 = sdk2;
+          await sdkObj2[sdkMethodName](resolvedParams);
+          console.log(
+            chalk3.green(`\u2705 ${cliCommandName} completed successfully!`)
+          );
+          console.log(chalk3.gray(`Output written to: ${hasOutputFile}`));
+          return;
+        }
+        const sdkObj = sdk2;
+        const result = await sdkObj[sdkMethodName](resolvedParams);
         const items = result?.data ? result.data : result;
         if (shouldUseJson) {
           console.log(JSON.stringify(items, null, 2));
@@ -608,8 +698,13 @@ function createCommandConfig(cliCommandName, sdkMethodName, schema, sdk2) {
           const validationErrors = JSON.parse(error.message);
           console.error(chalk3.red("\u274C Validation Error:"));
           validationErrors.forEach((err) => {
-            const field = err.path?.join(".") || "unknown";
-            console.error(chalk3.yellow(`  \u2022 ${field}: ${err.message}`));
+            const errorObj = err;
+            const field = errorObj?.path?.join(".") || "unknown";
+            console.error(
+              chalk3.yellow(
+                `  \u2022 ${field}: ${errorObj?.message || "Unknown error"}`
+              )
+            );
           });
           console.error(
             "\n" + chalk3.dim(`Use --help to see available options`)
@@ -658,10 +753,18 @@ function addCommand(program2, commandName, config) {
         command.option(flags.join(", "), param.description);
       } else if (param.type === "array") {
         const flagSignature = flags.join(", ") + ` <values...>`;
-        command.option(flagSignature, param.description, param.default);
+        command.option(
+          flagSignature,
+          param.description,
+          param.default
+        );
       } else {
         const flagSignature = flags.join(", ") + ` <${param.type}>`;
-        command.option(flagSignature, param.description, param.default);
+        command.option(
+          flagSignature,
+          param.description || "",
+          param.default
+        );
       }
     }
   });
@@ -826,10 +929,11 @@ function formatNonPaginatedResults(result, requestedMaxItems, userSpecifiedMaxIt
 }
 function formatItemsGeneric2(items) {
   items.forEach((item, index) => {
-    const name = item.title || item.name || item.key || item.id || "Item";
-    console.log(`${chalk3.gray(`${index + 1}.`)} ${chalk3.cyan(name)}`);
-    if (item.description) {
-      console.log(`   ${chalk3.dim(item.description)}`);
+    const itemObj = item;
+    const name = itemObj?.name || itemObj?.key || itemObj?.id || "Item";
+    console.log(`${chalk3.gray(`${index + 1}.`)} ${chalk3.cyan(String(name))}`);
+    if (itemObj?.description) {
+      console.log(`   ${chalk3.dim(String(itemObj.description))}`);
     }
     console.log();
   });
@@ -1150,7 +1254,8 @@ var GenerateTypesSchema = z3.object({
   ),
   debug: DebugPropertySchema.describe(
     "Enable debug logging during generation"
-  )
+  ),
+  lockFilePath: z3.string().optional().describe("Path to the .zapierrc lock file (defaults to .zapierrc)")
 }).describe("Generate TypeScript SDK code for a specific app");
 
 // src/commands/generate-types/index.ts
@@ -1184,21 +1289,41 @@ async function generateTypes(options) {
   if (authenticationId) {
     for (const action of actions) {
       try {
+        const manifestEntry = sdk2.getContext().getManifestEntry(appKey);
         const fieldsResult = await sdk2.listInputFields({
-          appKey: action.app_key,
+          // If the appKey is in the manifest, use the appKey so that the types are consistent with the manifest's version, otherwise use the action.app_key
+          appKey: manifestEntry ? appKey : action.app_key,
           actionKey: action.key,
           actionType: action.action_type,
           authenticationId
         });
-        const fields = fieldsResult.data;
-        actionsWithFields.push({ ...action, inputFields: fields });
+        const fields = fieldsResult.data.map((field) => {
+          const fieldObj = field;
+          return {
+            ...fieldObj,
+            required: fieldObj.is_required || fieldObj.required || false
+          };
+        });
+        actionsWithFields.push({
+          ...action,
+          inputFields: fields,
+          name: action.title || action.key
+        });
       } catch {
-        actionsWithFields.push({ ...action, inputFields: [] });
+        actionsWithFields.push({
+          ...action,
+          inputFields: [],
+          name: action.title || action.key
+        });
       }
     }
   } else {
     actions.forEach((action) => {
-      actionsWithFields.push({ ...action, inputFields: [] });
+      actionsWithFields.push({
+        ...action,
+        inputFields: [],
+        name: action.title || action.key
+      });
     });
   }
   const typeDefinitions = generateTypeDefinitions(
@@ -1556,7 +1681,11 @@ function createGenerateTypesCommand() {
         command.option(flags.join(", "), param.description);
       } else {
         const flagSignature = flags.join(", ") + ` <${param.type}>`;
-        command.option(flagSignature, param.description, param.default);
+        command.option(
+          flagSignature,
+          param.description || "",
+          param.default
+        );
       }
     }
   });
@@ -1570,23 +1699,33 @@ function createGenerateTypesCommand() {
         args.slice(0, -1),
         options
       );
-      const sdk2 = createZapierSdk();
+      const sdk2 = createZapierSdk({
+        manifestPath: rawParams.lockFilePath
+      });
       const resolver = new SchemaParameterResolver();
       const resolvedParams = await resolver.resolveParameters(
         GenerateTypesSchema,
         rawParams,
         sdk2
       );
+      const params = resolvedParams;
       console.log(
         chalk5.blue(
-          `\u{1F527} Generating TypeScript types for ${resolvedParams.appKey}...`
+          `\u{1F527} Generating TypeScript types for ${params.appKey}...`
         )
       );
-      const result = await generateTypes({ ...resolvedParams, sdk: sdk2 });
+      const generateTypesParams = {
+        appKey: params.appKey,
+        debug: params.debug ?? false,
+        authenticationId: params.authenticationId,
+        output: params.output,
+        sdk: sdk2
+      };
+      const result = await generateTypes(generateTypesParams);
       if (options.json) {
         console.log(JSON.stringify({ result }, null, 2));
       } else {
-        const output = resolvedParams.output || `./types/${resolvedParams.appKey}.d.ts`;
+        const output = params.output || `./types/${params.appKey}.d.ts`;
         console.log(chalk5.green("\u2705 TypeScript types generated successfully!"));
         console.log(chalk5.gray(`Output written to: ${output}`));
       }
@@ -1717,7 +1856,11 @@ function createBundleCodeCommand() {
         command.option(flags.join(", "), param.description);
       } else {
         const flagSignature = flags.join(", ") + ` <${param.type}>`;
-        command.option(flagSignature, param.description, param.default);
+        command.option(
+          flagSignature,
+          param.description || "",
+          param.default
+        );
       }
     }
   });
@@ -1735,7 +1878,9 @@ function createBundleCodeCommand() {
         throw new Error("Input file path is required");
       }
       console.log(chalk6.blue(`\u{1F4E6} Bundling ${rawParams.input}...`));
-      const result = await bundleCode(rawParams);
+      const result = await bundleCode(
+        rawParams
+      );
       if (options.json) {
         console.log(JSON.stringify({ result }, null, 2));
       } else if (rawParams.output && !rawParams.string) {
@@ -1770,7 +1915,7 @@ function createMcpCommand() {
 
 // src/cli.ts
 var program = new Command7();
-program.name("zapier-sdk").description("CLI for Zapier SDK - Commands auto-generated from SDK schemas").version("1.0.0").option("--debug", "Enable debug logging");
+program.name("zapier-sdk").description("CLI for Zapier SDK").version("1.0.0").option("--debug", "Enable debug logging");
 var isDebugMode = process.env.DEBUG === "true" || process.argv.includes("--debug");
 var sdk = createZapierSdk2({
   debug: isDebugMode

package/dist/src/cli.js

@@ -6,7 +6,7 @@ import { createLoginCommand, createLogoutCommand, createConfigPathCommand, creat
 const program = new Command();
 program
     .name("zapier-sdk")
-    .description("CLI for Zapier SDK - Commands auto-generated from SDK schemas")
+    .description("CLI for Zapier SDK")
     .version("1.0.0")
     .option("--debug", "Enable debug logging");
 // Check for debug flag early

package/dist/src/commands/bundle-code/cli.js

@@ -32,7 +32,7 @@ export function createBundleCodeCommand() {
             }
             else {
                 const flagSignature = flags.join(", ") + ` <${param.type}>`;
-                command.option(flagSignature, param.description, param.default);
+                command.option(flagSignature, param.description || "", param.default);
             }
         }
     });

package/dist/src/commands/generate-types/cli.js

@@ -34,7 +34,7 @@ export function createGenerateTypesCommand() {
             }
             else {
                 const flagSignature = flags.join(", ") + ` <${param.type}>`;
-                command.option(flagSignature, param.description, param.default);
+                command.option(flagSignature, param.description || "", param.default);
             }
         }
     });
@@ -47,19 +47,30 @@ export function createGenerateTypesCommand() {
             const options = commandObj.opts();
             // Convert CLI args to SDK method parameters
             const rawParams = convertCliArgsToSdkParams(parameters, args.slice(0, -1), options);
-            // Create SDK instance
-            const sdk = createZapierSdk();
+            // Create SDK instance with manifest path if provided
+            const sdk = createZapierSdk({
+                manifestPath: rawParams.lockFilePath,
+            });
             // Resolve missing parameters interactively using schema metadata
             const resolver = new SchemaParameterResolver();
             const resolvedParams = await resolver.resolveParameters(GenerateTypesSchema, rawParams, sdk);
-            console.log(chalk.blue(`🔧 Generating TypeScript types for ${resolvedParams.appKey}...`));
+            const params = resolvedParams;
+            console.log(chalk.blue(`🔧 Generating TypeScript types for ${params.appKey}...`));
             // Call our implementation
-            const result = await generateTypes({ ...resolvedParams, sdk });
+            const generateTypesParams = {
+                appKey: params.appKey,
+                debug: params.debug ?? false,
+                authenticationId: params.authenticationId,
+                output: params.output,
+                sdk,
+            };
+            const result = await generateTypes(generateTypesParams);
             if (options.json) {
                 console.log(JSON.stringify({ result }, null, 2));
             }
             else {
-                const output = resolvedParams.output || `./types/${resolvedParams.appKey}.d.ts`;
+                const output = params.output ||
+                    `./types/${params.appKey}.d.ts`;
                 console.log(chalk.green("✅ TypeScript types generated successfully!"));
                 console.log(chalk.gray(`Output written to: ${output}`));
             }

package/dist/src/commands/generate-types/index.js

@@ -32,25 +32,46 @@ export async function generateTypes(options) {
     if (authenticationId) {
         for (const action of actions) {
             try {
+                // Check to see if the appKey is in the manifest
+                const manifestEntry = sdk.getContext().getManifestEntry(appKey);
                 const fieldsResult = await sdk.listInputFields({
-                    appKey: action.app_key,
+                    // If the appKey is in the manifest, use the appKey so that the types are consistent with the manifest's version, otherwise use the action.app_key
+                    appKey: manifestEntry ? appKey : action.app_key,
                     actionKey: action.key,
                     actionType: action.action_type,
                     authenticationId: authenticationId,
                 });
-                const fields = fieldsResult.data; // Direct array result
-                actionsWithFields.push({ ...action, inputFields: fields });
+                const fields = fieldsResult.data.map((field) => {
+                    const fieldObj = field;
+                    return {
+                        ...fieldObj,
+                        required: fieldObj.is_required || fieldObj.required || false,
+                    };
+                });
+                actionsWithFields.push({
+                    ...action,
+                    inputFields: fields,
+                    name: action.title || action.key,
+                });
             }
             catch {
                 // If we can't get fields for an action, include it without fields
-                actionsWithFields.push({ ...action, inputFields: [] });
+                actionsWithFields.push({
+                    ...action,
+                    inputFields: [],
+                    name: action.title || action.key,
+                });
             }
         }
     }
     else {
         // Convert actions to have empty input fields (will generate generic types)
         actions.forEach((action) => {
-            actionsWithFields.push({ ...action, inputFields: [] });
+            actionsWithFields.push({
+                ...action,
+                inputFields: [],
+                name: action.title || action.key,
+            });
         });
     }
     // Generate TypeScript types

package/dist/src/commands/generate-types/schemas.d.ts

@@ -4,15 +4,18 @@ export declare const GenerateTypesSchema: z.ZodObject<{
     authenticationId: z.ZodOptional<z.ZodNumber>;
     output: z.ZodOptional<z.ZodString>;
     debug: z.ZodDefault<z.ZodBoolean>;
+    lockFilePath: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     appKey: string;
     debug: boolean;
     authenticationId?: number | undefined;
     output?: string | undefined;
+    lockFilePath?: string | undefined;
 }, {
     appKey: string;
     authenticationId?: number | undefined;
     output?: string | undefined;
     debug?: boolean | undefined;
+    lockFilePath?: string | undefined;
 }>;
 export type GenerateTypesOptions = z.infer<typeof GenerateTypesSchema>;

package/dist/src/commands/generate-types/schemas.js

@@ -7,5 +7,9 @@ export const GenerateTypesSchema = z
     authenticationId: AuthenticationIdPropertySchema.optional(),
     output: OutputPropertySchema.optional().describe("Output file path (defaults to generated/<appKey>.ts)"),
     debug: DebugPropertySchema.describe("Enable debug logging during generation"),
+    lockFilePath: z
+        .string()
+        .optional()
+        .describe("Path to the .zapierrc lock file (defaults to .zapierrc)"),
 })
     .describe("Generate TypeScript SDK code for a specific app");

package/dist/src/utils/api/client.d.ts

@@ -1,14 +1,14 @@
-export interface ApiResponse<T = any> {
+export interface ApiResponse<T = unknown> {
     data: T;
     status: number;
 }
 export declare const createApiClient: () => {
-    post: <T = any>(url: string, data: any, options?: {
+    post: <T = unknown>(url: string, data: Record<string, string>, options?: {
         headers?: Record<string, string>;
     }) => Promise<ApiResponse<T>>;
 };
 declare const api: {
-    post: <T = any>(url: string, data: any, options?: {
+    post: <T = unknown>(url: string, data: Record<string, string>, options?: {
         headers?: Record<string, string>;
     }) => Promise<ApiResponse<T>>;
 };

package/dist/src/utils/cli-generator-utils.d.ts

@@ -4,10 +4,10 @@ export interface CliParameter {
     type: "string" | "number" | "boolean" | "array";
     required: boolean;
     description?: string;
-    default?: any;
+    default?: unknown;
     choices?: string[];
     hasResolver?: boolean;
     isPositional?: boolean;
 }
 export declare function analyzeZodSchema(schema: z.ZodSchema): CliParameter[];
-export declare function convertCliArgsToSdkParams(parameters: CliParameter[], positionalArgs: any[], options: Record<string, any>): Record<string, any>;
+export declare function convertCliArgsToSdkParams(parameters: CliParameter[], positionalArgs: unknown[], options: Record<string, unknown>): Record<string, unknown>;