@zapier/zapier-sdk-cli 0.19.0 → 0.22.0

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

@@ -1,555 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,5 +0,0 @@
-// 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

@@ -1,5 +0,0 @@
-/**
- * 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

@@ -1,21 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

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

package/dist/src/utils/getCallablePromise.js

@@ -1,14 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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;