@zapier/zapier-sdk-cli 0.22.0 → 0.22.1

package/dist/src/utils/cli-generator.js

@@ -0,0 +1,555 @@
+import { z } from "zod";
+import { isPositional, formatErrorMessage, ZapierError, } from "@zapier/zapier-sdk";
+import { SchemaParameterResolver } from "./parameter-resolver";
+import { formatItemsFromSchema, formatJsonOutput } from "./schema-formatter";
+import chalk from "chalk";
+import inquirer from "inquirer";
+import { ZapierCliError, ZapierCliExitError } from "./errors";
+// ============================================================================
+// Schema Analysis
+// ============================================================================
+function analyzeZodSchema(schema, functionInfo) {
+    const parameters = [];
+    // Handle ZodEffects (schemas with .refine(), .transform(), etc.)
+    // In Zod, effects have type "effect" and inner schema is accessed via innerType
+    const schemaDef = schema._zod?.def;
+    if (schemaDef?.type === "effect" && schemaDef.innerType) {
+        return analyzeZodSchema(schemaDef.innerType, functionInfo);
+    }
+    if (schema instanceof z.ZodObject) {
+        const shape = schema.shape;
+        for (const [key, fieldSchema] of Object.entries(shape)) {
+            const param = analyzeZodField(key, fieldSchema, functionInfo);
+            if (param) {
+                parameters.push(param);
+            }
+        }
+    }
+    return parameters;
+}
+function analyzeZodField(name, schema, functionInfo) {
+    let baseSchema = schema;
+    let required = true;
+    let defaultValue = undefined;
+    // Unwrap optional, default, and nullable wrappers - keep unwrapping until we get to the base type
+    while (true) {
+        if (baseSchema instanceof z.ZodOptional) {
+            required = false;
+            baseSchema = baseSchema._zod.def.innerType;
+        }
+        else if (baseSchema instanceof z.ZodDefault) {
+            required = false;
+            defaultValue = baseSchema._zod.def.defaultValue();
+            baseSchema = baseSchema._zod.def.innerType;
+        }
+        else {
+            // Check for ZodNullable - nullable doesn't affect CLI required status, but we need to unwrap it to get the base type
+            // Use _zod.def.type for Zod 4 compatibility (matches patterns elsewhere in codebase)
+            const zodDef = baseSchema._zod?.def;
+            if (zodDef?.type === "nullable" && zodDef.innerType) {
+                baseSchema = zodDef.innerType;
+                continue;
+            }
+            // No more wrappers to unwrap
+            break;
+        }
+    }
+    // Determine parameter type
+    let paramType = "string";
+    let choices;
+    if (baseSchema instanceof z.ZodString) {
+        paramType = "string";
+    }
+    else if (baseSchema instanceof z.ZodNumber) {
+        paramType = "number";
+    }
+    else if (baseSchema instanceof z.ZodBoolean) {
+        paramType = "boolean";
+    }
+    else if (baseSchema instanceof z.ZodArray) {
+        paramType = "array";
+    }
+    else if (baseSchema instanceof z.ZodEnum) {
+        paramType = "string";
+        choices = baseSchema.options;
+    }
+    else if (baseSchema instanceof z.ZodRecord) {
+        // Handle Record<string, any> as JSON string input
+        paramType = "string";
+    }
+    // Check if this parameter has a resolver
+    let paramHasResolver = false;
+    // Check function-specific resolvers first
+    if (functionInfo?.resolvers?.[name]) {
+        paramHasResolver = true;
+    }
+    // Extract resolver metadata
+    return {
+        name,
+        type: paramType,
+        required,
+        description: schema.description,
+        default: defaultValue,
+        choices,
+        hasResolver: paramHasResolver,
+        isPositional: isPositional(schema),
+    };
+}
+// ============================================================================
+// CLI Structure Derivation - Purely Generic
+// ============================================================================
+/**
+ * Convert camelCase to kebab-case
+ * e.g., listApps -> list-apps, generateTypes -> generate-types
+ */
+function toKebabCase(str) {
+    return str.replace(/([A-Z])/g, "-$1").toLowerCase();
+}
+/**
+ * Convert SDK method name directly to CLI command
+ * e.g., listApps -> list-apps, getApp -> get-app, generateTypes -> generate-types
+ */
+function methodNameToCliCommand(methodName) {
+    return toKebabCase(methodName);
+}
+// ============================================================================
+// CLI Command Generation - Completely Generic
+// ============================================================================
+export function generateCliCommands(program, sdk) {
+    // Check if SDK has registry
+    if (typeof sdk.getRegistry !== "function") {
+        console.error("SDK registry not available");
+        return;
+    }
+    const registry = sdk.getRegistry({ package: "cli" });
+    // Create all commands first
+    registry.functions.forEach((fnInfo) => {
+        if (!fnInfo.inputSchema) {
+            console.warn(`Schema not found for ${fnInfo.name}`);
+            return;
+        }
+        // Convert methodName to kebab-case CLI command
+        const cliCommandName = methodNameToCliCommand(fnInfo.name);
+        const config = createCommandConfig(cliCommandName, fnInfo, sdk);
+        addCommand(program, cliCommandName, config);
+    });
+    // Override the help display to show commands grouped by category
+    program.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";
+            }
+            // Add options section
+            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)}\n`;
+                });
+            }
+            // Add categorized commands section
+            const commands = helper.visibleCommands(cmd);
+            if (commands.length > 0) {
+                output += "\nCommands:\n";
+                // Collect all SDK commands that belong to categories
+                const categorizedCommands = new Set();
+                // Group SDK commands by categories
+                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 += `\n  ${category.titlePlural}:\n`;
+                        categoryCommands.forEach((command) => {
+                            output += `    ${helper.subcommandTerm(command)}\n`;
+                            categorizedCommands.add(command.name());
+                        });
+                    }
+                });
+                // Add any remaining commands that aren't part of SDK categories
+                const otherCommands = commands.filter((command) => !categorizedCommands.has(command.name()));
+                if (otherCommands.length > 0) {
+                    output += `\n  Other:\n`;
+                    otherCommands.forEach((command) => {
+                        output += `    ${helper.subcommandTerm(command)}\n`;
+                    });
+                }
+            }
+            return output;
+        },
+    });
+}
+function createCommandConfig(cliCommandName, functionInfo, sdk) {
+    const schema = functionInfo.inputSchema;
+    const parameters = analyzeZodSchema(schema, functionInfo);
+    const description = schema.description || `${cliCommandName} command`;
+    const handler = async (...args) => {
+        try {
+            // The last argument is always the command object with parsed options
+            const commandObj = args[args.length - 1];
+            const options = commandObj.opts();
+            // Check if this is a list command for pagination
+            const isListCommand = functionInfo.type === "list";
+            const hasPaginationParams = parameters.some((p) => p.name === "maxItems" || p.name === "pageSize");
+            const hasUserSpecifiedMaxItems = "maxItems" in options && options.maxItems !== undefined;
+            const shouldUseJson = options.json;
+            // Convert CLI args to SDK method parameters
+            const rawParams = convertCliArgsToSdkParams(parameters, args.slice(0, -1), options);
+            // Resolve missing parameters interactively using schema metadata
+            const resolver = new SchemaParameterResolver();
+            const resolvedParams = await resolver.resolveParameters(schema, rawParams, sdk, functionInfo.name);
+            // Handle paginated list commands with async iteration
+            if (isListCommand &&
+                hasPaginationParams &&
+                !shouldUseJson &&
+                !hasUserSpecifiedMaxItems) {
+                // Get the async iterable directly from the SDK method call (don't await it! that breaks the next page behavior)
+                const sdkObj = sdk;
+                const sdkIterator = sdkObj[functionInfo.name](resolvedParams);
+                await handlePaginatedListWithAsyncIteration(functionInfo.name, sdkIterator, functionInfo);
+            }
+            else {
+                // Special handling for commands that write to files
+                const hasOutputFile = resolvedParams.output;
+                if (hasOutputFile) {
+                    // Call the SDK method for file output commands
+                    const sdkObj = sdk;
+                    await sdkObj[functionInfo.name](resolvedParams);
+                    console.log(chalk.green(`✅ ${cliCommandName} completed successfully!`));
+                    console.log(chalk.gray(`Output written to: ${hasOutputFile}`));
+                    return;
+                }
+                // Call the SDK method and handle non-paginated results
+                const sdkObj = sdk;
+                let result = await sdkObj[functionInfo.name](resolvedParams);
+                // Handle Response objects by wrapping in a structured envelope
+                if (result instanceof Response) {
+                    const response = result;
+                    let body;
+                    // Read as text first to preserve body for error messages
+                    const text = await response
+                        .text()
+                        .catch(() => "[unable to read body]");
+                    try {
+                        body = JSON.parse(text);
+                    }
+                    catch {
+                        throw new Error(`Failed to parse response as JSON (status: ${response.status}). Body: ${text.slice(0, 500)}`);
+                    }
+                    result = {
+                        statusCode: response.status,
+                        headers: Object.fromEntries(response.headers.entries()),
+                        body,
+                    };
+                }
+                const items = result?.data
+                    ? result.data
+                    : result;
+                if (shouldUseJson) {
+                    console.log(JSON.stringify(items, null, 2));
+                }
+                else if (isListCommand) {
+                    formatNonPaginatedResults(items, resolvedParams.maxItems, hasUserSpecifiedMaxItems, shouldUseJson, functionInfo);
+                }
+                else {
+                    formatJsonOutput(items);
+                }
+            }
+        }
+        catch (error) {
+            // Handle Zod validation errors more gracefully
+            if (error instanceof Error && error.message.includes('"code"')) {
+                try {
+                    const validationErrors = JSON.parse(error.message);
+                    console.error(chalk.red("❌ Validation Error:"));
+                    validationErrors.forEach((err) => {
+                        const errorObj = err;
+                        const field = errorObj?.path?.join(".") || "unknown";
+                        console.error(chalk.yellow(`  • ${field}: ${errorObj?.message || "Unknown error"}`));
+                    });
+                    console.error("\n" + chalk.dim(`Use --help to see available options`));
+                    throw new ZapierCliExitError("Validation failed", 1);
+                }
+                catch {
+                    console.error(chalk.red("Error:"), error instanceof Error ? error.message : String(error));
+                    throw new ZapierCliExitError(error instanceof Error ? error.message : String(error), 1);
+                }
+            }
+            else if (error instanceof ZapierCliError) {
+                // Re-throw all CLI errors as-is
+                throw error;
+            }
+            else if (error instanceof ZapierError) {
+                // Handle SDK errors with clean, user-friendly messages using our formatter
+                const formattedMessage = formatErrorMessage(error);
+                console.error(chalk.red("❌ Error:"), formattedMessage);
+                throw new ZapierCliExitError(formattedMessage, 1);
+            }
+            else {
+                // Handle other errors
+                const errorMessage = error instanceof Error ? error.message : "Unknown error";
+                console.error(chalk.red("❌ Error:"), errorMessage);
+                throw new ZapierCliExitError(errorMessage, 1);
+            }
+        }
+    };
+    return {
+        description,
+        parameters,
+        handler,
+    };
+}
+function addCommand(program, commandName, config) {
+    const command = program.command(commandName).description(config.description);
+    // Track whether we've already used a positional array parameter
+    let hasPositionalArray = false;
+    // Add parameters to command
+    config.parameters.forEach((param) => {
+        // Convert camelCase to kebab-case for CLI display
+        const kebabName = param.name.replace(/([A-Z])/g, "-$1").toLowerCase();
+        if (param.hasResolver && param.required) {
+            // Required parameters with resolvers become optional positional arguments (resolver handles prompting)
+            command.argument(`[${kebabName}]`, param.description || `${kebabName} parameter`);
+        }
+        else if (param.required &&
+            param.type === "array" &&
+            !hasPositionalArray) {
+            // First required array parameter becomes a variadic positional argument
+            hasPositionalArray = true;
+            command.argument(`<${kebabName}...>`, param.description || `${kebabName} parameter`);
+        }
+        else if (param.required && param.type === "array") {
+            // Subsequent required array parameters become required flags
+            const flags = [`--${kebabName}`];
+            const flagSignature = flags.join(", ") + ` <values...>`;
+            command.requiredOption(flagSignature, param.description || `${kebabName} parameter (required)`);
+        }
+        else if (param.required) {
+            // Required parameters without resolvers become required positional arguments
+            command.argument(`<${kebabName}>`, param.description || `${kebabName} parameter`);
+        }
+        else if (param.isPositional) {
+            // Optional parameters marked as positional become optional positional arguments
+            command.argument(`[${kebabName}]`, param.description || `${kebabName} parameter`);
+        }
+        else {
+            // Optional parameters become flags (whether they have resolvers or not)
+            const flags = [`--${kebabName}`];
+            if (param.type === "boolean") {
+                command.option(flags.join(", "), param.description);
+            }
+            else if (param.type === "array") {
+                // For arrays, use variadic syntax to collect multiple values
+                const flagSignature = flags.join(", ") + ` <values...>`;
+                command.option(flagSignature, param.description, param.default);
+            }
+            else {
+                const flagSignature = flags.join(", ") + ` <${param.type}>`;
+                command.option(flagSignature, param.description || "", param.default);
+            }
+        }
+    });
+    // Add formatting options for all commands
+    command.option("--json", "Output raw JSON instead of formatted results");
+    command.action(config.handler);
+}
+// ============================================================================
+// Parameter Conversion
+// ============================================================================
+function convertCliArgsToSdkParams(parameters, positionalArgs, options) {
+    const sdkParams = {};
+    // Handle positional arguments (required parameters or optional positional parameters)
+    let argIndex = 0;
+    parameters.forEach((param) => {
+        if ((param.required || param.isPositional) &&
+            argIndex < positionalArgs.length) {
+            // Use the original camelCase parameter name for the SDK
+            sdkParams[param.name] = convertValue(positionalArgs[argIndex], param.type);
+            argIndex++;
+        }
+    });
+    // Handle option flags
+    Object.entries(options).forEach(([key, value]) => {
+        // Convert kebab-case back to camelCase
+        const camelKey = key.replace(/-([a-z])/g, (g) => g[1].toUpperCase());
+        const param = parameters.find((p) => p.name === camelKey);
+        if (param && value !== undefined) {
+            sdkParams[camelKey] = convertValue(value, param.type);
+        }
+    });
+    return sdkParams;
+}
+function convertValue(value, type) {
+    // Don't convert undefined values - let the resolver system handle them
+    if (value === undefined) {
+        return undefined;
+    }
+    switch (type) {
+        case "number":
+            return Number(value);
+        case "boolean":
+            return Boolean(value);
+        case "array":
+            return Array.isArray(value) ? value : [value];
+        case "string":
+        default:
+            // Handle JSON string for objects
+            if (typeof value === "string" &&
+                (value.startsWith("{") || value.startsWith("["))) {
+                try {
+                    return JSON.parse(value);
+                }
+                catch {
+                    return value;
+                }
+            }
+            return value;
+    }
+}
+// ============================================================================
+// Pagination Handlers
+// ============================================================================
+async function handlePaginatedListWithAsyncIteration(sdkMethodName, sdkResult, functionInfo) {
+    const itemName = getItemNameFromMethod(functionInfo);
+    let totalShown = 0;
+    let pageCount = 0;
+    console.log(chalk.blue(`📋 ${getListTitleFromMethod(sdkMethodName, functionInfo)}\n`));
+    try {
+        // Use async iteration to go through pages
+        for await (const page of sdkResult) {
+            const items = page.data || page;
+            pageCount++;
+            if (!Array.isArray(items)) {
+                console.log(chalk.yellow(`No ${itemName} found.`));
+                return;
+            }
+            if (items.length === 0 && pageCount === 1) {
+                console.log(chalk.yellow(`No ${itemName} found.`));
+                return;
+            }
+            if (items.length === 0) {
+                break; // No more items
+            }
+            // Clear screen for subsequent pages (not the first)
+            if (pageCount > 1) {
+                console.clear();
+                console.log(chalk.blue(`📋 ${getListTitleFromMethod(sdkMethodName, functionInfo)}\n`));
+            }
+            // Format and display items using function info
+            if (functionInfo && functionInfo.inputSchema) {
+                formatItemsFromSchema(functionInfo, items, totalShown);
+            }
+            else {
+                formatItemsGeneric(items, totalShown);
+            }
+            totalShown += items.length;
+            console.log(chalk.green(`\n✅ Showing ${totalShown} ${itemName} (page ${pageCount})`));
+            // Only prompt if there's a nextCursor (more pages available)
+            if (page.nextCursor) {
+                const { continueReading } = await inquirer.prompt([
+                    {
+                        type: "confirm",
+                        name: "continueReading",
+                        message: `Load next page?`,
+                        default: true,
+                    },
+                ]);
+                if (!continueReading) {
+                    break;
+                }
+            }
+            else {
+                // No more pages available, exit gracefully
+                break;
+            }
+        }
+        console.log(chalk.gray(`\n📄 Finished browsing ${itemName}`));
+    }
+    catch (error) {
+        // If the result is not async iterable, fall back to showing the first page
+        const items = sdkResult?.data || sdkResult;
+        if (Array.isArray(items)) {
+            if (items.length === 0) {
+                console.log(chalk.yellow(`No ${itemName} found.`));
+                return;
+            }
+            if (functionInfo && functionInfo.inputSchema) {
+                formatItemsFromSchema(functionInfo, items, 0);
+            }
+            else {
+                formatItemsGeneric(items, 0);
+            }
+            console.log(chalk.green(`\n✅ Showing ${items.length} ${itemName}`));
+        }
+        else {
+            throw error;
+        }
+    }
+}
+function formatNonPaginatedResults(result, requestedMaxItems, userSpecifiedMaxItems, useRawJson, functionInfo) {
+    if (!Array.isArray(result)) {
+        if (useRawJson) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            formatJsonOutput(result);
+        }
+        return;
+    }
+    if (useRawJson) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    const itemName = functionInfo ? getItemNameFromMethod(functionInfo) : "items";
+    if (result.length === 0) {
+        console.log(chalk.yellow(`No ${itemName} found.`));
+        return;
+    }
+    console.log(chalk.green(`\n✅ Found ${result.length} ${itemName}:\n`));
+    // Use function info for formatting
+    if (functionInfo && functionInfo.inputSchema) {
+        formatItemsFromSchema(functionInfo, result);
+    }
+    else {
+        // Fallback to generic formatting
+        formatItemsGeneric(result);
+    }
+    // Show appropriate status message
+    if (userSpecifiedMaxItems && requestedMaxItems) {
+        console.log(chalk.gray(`\n📄 Showing up to ${requestedMaxItems} ${itemName} (--max-items ${requestedMaxItems})`));
+    }
+    else {
+        console.log(chalk.gray(`\n📄 All available ${itemName} shown`));
+    }
+}
+function formatItemsGeneric(items, startingNumber = 0) {
+    // Fallback formatting for items without schema metadata
+    items.forEach((item, index) => {
+        const itemObj = item;
+        const name = itemObj?.name || itemObj?.key || itemObj?.id || "Item";
+        console.log(`${chalk.gray(`${startingNumber + index + 1}.`)} ${chalk.cyan(String(name))}`);
+        if (itemObj?.description) {
+            console.log(`   ${chalk.dim(String(itemObj.description))}`);
+        }
+        console.log();
+    });
+}
+// Generic helper functions that infer from schema description or method name
+function getItemNameFromMethod(functionInfo) {
+    if (functionInfo.itemType) {
+        return `${functionInfo.itemType} items`;
+    }
+    return "items";
+}
+function getListTitleFromMethod(methodName, functionInfo) {
+    if (functionInfo.itemType) {
+        return `Available ${functionInfo.itemType} items`;
+    }
+    return `${methodName} items`;
+}

package/dist/src/utils/constants.d.ts

@@ -0,0 +1,3 @@
+export { AUTH_MODE_HEADER } from "@zapier/zapier-sdk-cli-login";
+export declare const LOGIN_PORTS: number[];
+export declare const LOGIN_TIMEOUT_MS = 300000;

package/dist/src/utils/constants.js

@@ -0,0 +1,5 @@
+// Import shared OAuth constants from login package
+export { AUTH_MODE_HEADER } from "@zapier/zapier-sdk-cli-login";
+// CLI-specific constants
+export const LOGIN_PORTS = [49505, 50575, 52804, 55981, 61010, 63851];
+export const LOGIN_TIMEOUT_MS = 300000; // 5 minutes

package/dist/src/utils/directory-detection.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Detect the best default directory for TypeScript types
+ * Looks for src or lib directories, falls back to current directory
+ */
+export declare function detectTypesOutputDirectory(): Promise<string>;

package/dist/src/utils/directory-detection.js

@@ -0,0 +1,21 @@
+import { access } from "fs/promises";
+import { join } from "path";
+/**
+ * Detect the best default directory for TypeScript types
+ * Looks for src or lib directories, falls back to current directory
+ */
+export async function detectTypesOutputDirectory() {
+    // Check for common source directories in priority order
+    const candidates = ["src", "lib"];
+    for (const candidate of candidates) {
+        try {
+            await access(candidate);
+            return join(candidate, "zapier", "apps");
+        }
+        catch {
+            // Directory doesn't exist, continue to next candidate
+        }
+    }
+    // Fall back to current directory
+    return "./zapier/apps/";
+}

package/dist/src/utils/errors.d.ts

@@ -0,0 +1,16 @@
+import { ZapierError } from "@zapier/zapier-sdk";
+export declare abstract class ZapierCliError extends ZapierError {
+    abstract readonly exitCode: number;
+}
+export declare class ZapierCliUserCancellationError extends ZapierCliError {
+    readonly name = "ZapierCliUserCancellationError";
+    readonly code = "ZAPIER_CLI_USER_CANCELLATION";
+    readonly exitCode = 0;
+    constructor(message?: string);
+}
+export declare class ZapierCliExitError extends ZapierCliError {
+    readonly name = "ZapierCliExitError";
+    readonly code = "ZAPIER_CLI_EXIT";
+    readonly exitCode: number;
+    constructor(message: string, exitCode?: number);
+}

package/dist/src/utils/errors.js

@@ -0,0 +1,19 @@
+import { ZapierError } from "@zapier/zapier-sdk";
+export class ZapierCliError extends ZapierError {
+}
+export class ZapierCliUserCancellationError extends ZapierCliError {
+    constructor(message = "Operation cancelled by user") {
+        super(message);
+        this.name = "ZapierCliUserCancellationError";
+        this.code = "ZAPIER_CLI_USER_CANCELLATION";
+        this.exitCode = 0;
+    }
+}
+export class ZapierCliExitError extends ZapierCliError {
+    constructor(message, exitCode = 1) {
+        super(message);
+        this.name = "ZapierCliExitError";
+        this.code = "ZAPIER_CLI_EXIT";
+        this.exitCode = exitCode;
+    }
+}

package/dist/src/utils/getCallablePromise.d.ts

@@ -0,0 +1,6 @@
+declare const getCallablePromise: <T>() => {
+    promise: Promise<T>;
+    resolve: (value: T) => void;
+    reject: (reason: unknown) => void;
+};
+export default getCallablePromise;

package/dist/src/utils/getCallablePromise.js

@@ -0,0 +1,14 @@
+const getCallablePromise = () => {
+    let resolve = () => { };
+    let reject = () => { };
+    const promise = new Promise((_resolve, _reject) => {
+        resolve = _resolve;
+        reject = _reject;
+    });
+    return {
+        promise,
+        resolve,
+        reject,
+    };
+};
+export default getCallablePromise;

package/dist/src/utils/log.d.ts

@@ -0,0 +1,8 @@
+declare const log: {
+    info: (message: string, ...args: unknown[]) => void;
+    error: (message: string, ...args: unknown[]) => void;
+    success: (message: string, ...args: unknown[]) => void;
+    warn: (message: string, ...args: unknown[]) => void;
+    debug: (message: string, ...args: unknown[]) => void;
+};
+export default log;