@mtndev/cli 0.0.0-dev-20260618142325

package/cjs/__chunks/INFOPAHN.cjs

@@ -0,0 +1,117 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+var _4SFWHCB3cjs = require('./4SFWHCB3.cjs');
+
+
+
+var _J36P6UNEcjs = require('./J36P6UNE.cjs');
+
+// src/commands/icons/handler.js
+var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
+var _zod = require('zod');
+async function iconsCommand(options) {
+  try {
+    const validatedOptions = _J36P6UNEcjs.iconsCommandOptionsSchema.parse(options);
+    if (validatedOptions.help) {
+      console.log(_chalk2.default.bold(`
+Usage: mtn icons <input> [options]`));
+      console.log(_chalk2.default.gray(_J36P6UNEcjs.iconsCommandMetadata.description));
+      console.log(_chalk2.default.bold("\nOptions:"));
+      Object.entries(_J36P6UNEcjs.iconsCommandOptionsSchema.shape).forEach(
+        ([key, fieldSchema]) => {
+          if (key === "input") return;
+          const description = fieldSchema.description || "No description available";
+          const optionMeta = (
+            /** @type {any} */
+            _J36P6UNEcjs.iconsCommandMetadata.options[key]
+          );
+          const defaultValue = _nullishCoalesce(_optionalChain([optionMeta, 'optionalAccess', _ => _.default]), () => ( false));
+          const alias = _optionalChain([optionMeta, 'optionalAccess', _2 => _2.alias]) ? _chalk2.default.cyan(`, -${optionMeta.alias}`) : "";
+          console.log(
+            _chalk2.default.cyan(`  --${key}`) + alias + `  ${description} (default: ${defaultValue})`
+          );
+        }
+      );
+      console.log("");
+      return;
+    }
+    const { input, channels, iconTypes, verbose } = validatedOptions;
+    if (verbose) {
+      console.log(_chalk2.default.blue("\n\u{1F4F1} Icon Generation"));
+      console.log(_chalk2.default.gray(`   Input directory: ${input}`));
+      console.log(_chalk2.default.gray(`   Channels: ${channels.join(", ")}`));
+      console.log(_chalk2.default.gray(`   Icon types: ${iconTypes.join(", ")}`));
+    }
+    _4SFWHCB3cjs.checkDependencies.call(void 0, verbose);
+    _4SFWHCB3cjs.validateBaseIcons.call(void 0, input, iconTypes, verbose);
+    const result = _4SFWHCB3cjs.generateAllIcons.call(void 0, {
+      baseDir: input,
+      channels,
+      iconTypes,
+      verbose
+    });
+    console.log(_chalk2.default.bold("\n\u{1F4CA} Summary:"));
+    console.log(
+      _chalk2.default.green(
+        `   \u2713 Successfully generated: ${result.success.length} icon(s)`
+      )
+    );
+    if (result.failed.length > 0) {
+      console.log(_chalk2.default.red(`   \u2717 Failed: ${result.failed.length} icon(s)`));
+      result.failed.forEach(({ icon, error }) => {
+        console.log(_chalk2.default.red(`     - ${icon}: ${error}`));
+      });
+      process.exit(1);
+    }
+    console.log(_chalk2.default.green(`
+\u2705 All icons generated successfully!`));
+  } catch (error) {
+    if (error instanceof _zod.ZodError) {
+      console.error(_chalk2.default.red(`
+\u274C Invalid command options:`));
+      error.errors.forEach((err) => {
+        console.error(_chalk2.default.red(`   ${err.path.join(".")}: ${err.message}`));
+      });
+      process.exit(1);
+    }
+    const verbose = (
+      /** @type {any} */
+      _optionalChain([options, 'optionalAccess', _3 => _3.verbose]) || false
+    );
+    console.error(_chalk2.default.red(`
+\u274C Icon generation failed:`));
+    if (error instanceof Error) {
+      console.error(_chalk2.default.red(`   ${error.message}`));
+      if (verbose && error.stack) {
+        console.error(_chalk2.default.gray("\nStack trace:"));
+        console.error(_chalk2.default.gray(error.stack));
+      }
+    } else {
+      console.error(_chalk2.default.red(`   ${String(error)}`));
+    }
+    console.error(_chalk2.default.yellow("\n\u{1F4A1} Troubleshooting tips:"));
+    console.error(
+      _chalk2.default.yellow(
+        "   \u2022 Ensure ImageMagick is installed (brew install imagemagick)"
+      )
+    );
+    console.error(
+      _chalk2.default.yellow(
+        "   \u2022 Make sure icon.png and adaptive-icon.png exist in the input directory"
+      )
+    );
+    console.error(
+      _chalk2.default.yellow("   \u2022 Verify the input directory path is correct")
+    );
+    console.error(
+      _chalk2.default.yellow("   \u2022 Use --verbose for detailed error information\n")
+    );
+    process.exit(1);
+  }
+}
+
+
+
+exports.iconsCommand = iconsCommand;

package/cjs/__chunks/J36P6UNE.cjs

@@ -0,0 +1,75 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/commands/icons/schema.js
+var _zod = require('zod');
+var CHANNELS = ["dev", "staging", "test"];
+var ICON_TYPES = ["icon", "adaptive-icon"];
+var CHANNEL_TEXT_MAP = {
+  dev: "DEV",
+  local: "LOC",
+  staging: "STG",
+  test: "TST"
+};
+var ICON_SIZE_MAP = {
+  "adaptive-icon": 250,
+  icon: 378
+};
+var iconsCommandOptionsSchema = _zod.z.object({
+  input: _zod.z.string().describe(
+    "Path to the input image directory containing icon.png and adaptive-icon.png"
+  ),
+  channels: _zod.z.array(_zod.z.enum(["dev", "local", "staging", "test"])).optional().default(["dev", "local", "staging", "test"]).describe("Channels to generate icons for"),
+  iconTypes: _zod.z.array(_zod.z.enum(["icon", "adaptive-icon"])).optional().default(["icon", "adaptive-icon"]).describe("Icon types to generate"),
+  verbose: _zod.z.boolean().optional().default(false).describe("Enable verbose logging for detailed error information"),
+  help: _zod.z.boolean().optional().default(false).describe("Display help for command")
+});
+var iconsCommandMetadata = {
+  name: "icons",
+  description: `Generate app channel version icons with overlay text
+
+This command generates icon variants for different app channels (dev, local, staging, test)
+by overlaying text on base icon images using ImageMagick.
+
+Requirements:
+  \u2022 ImageMagick must be installed (brew install imagemagick)
+  \u2022 Base icons (icon.png, adaptive-icon.png) must exist in the input directory
+
+Examples:
+  $ mtn icons ./apps/my-app/assets          # Generate all channel icons
+  $ mtn icons ./assets -c dev,staging       # Generate only dev and staging icons
+  $ mtn icons ./assets -t icon              # Generate only standard icons
+  $ mtn icons ./assets -v                   # Verbose output`,
+  options: {
+    input: {
+      description: iconsCommandOptionsSchema.shape.input.description,
+      required: true
+    },
+    channels: {
+      description: iconsCommandOptionsSchema.shape.channels.description,
+      default: "dev,local,staging,test",
+      alias: "c"
+    },
+    iconTypes: {
+      description: iconsCommandOptionsSchema.shape.iconTypes.description,
+      default: "icon,adaptive-icon",
+      alias: "t"
+    },
+    verbose: {
+      description: iconsCommandOptionsSchema.shape.verbose.description,
+      default: false,
+      alias: "v"
+    },
+    help: {
+      description: iconsCommandOptionsSchema.shape.help.description,
+      default: false,
+      alias: "h"
+    }
+  }
+};
+
+
+
+
+
+
+
+
+exports.CHANNELS = CHANNELS; exports.ICON_TYPES = ICON_TYPES; exports.CHANNEL_TEXT_MAP = CHANNEL_TEXT_MAP; exports.ICON_SIZE_MAP = ICON_SIZE_MAP; exports.iconsCommandOptionsSchema = iconsCommandOptionsSchema; exports.iconsCommandMetadata = iconsCommandMetadata;

package/cjs/__chunks/NIMXXHJQ.cjs

@@ -0,0 +1,92 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }// src/commands/doppler/utils/exec.js
+var _child_process = require('child_process');
+var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
+function exec(command, options = {}) {
+  const {
+    stdoutParser = "string",
+    throwOnError = true,
+    verbosity = "default",
+    stdio: userStdio,
+    ...execSyncOptions
+  } = options;
+  try {
+    if (verbosity === "verbose") {
+      console.log(_chalk2.default.gray(`   Executing: ${command}`));
+    }
+    let stdio;
+    if (userStdio) {
+      stdio = userStdio;
+    } else if (verbosity === "verbose") {
+      stdio = "inherit";
+    } else if (verbosity === "silent") {
+      stdio = "pipe";
+    } else {
+      stdio = ["pipe", "pipe", "pipe"];
+    }
+    const result = (
+      /** @type {string} */
+      _child_process.execSync.call(void 0, command, {
+        encoding: "utf-8",
+        stdio,
+        ...execSyncOptions
+      })
+    );
+    if (stdio === "inherit") {
+      return stdoutParser === "string" ? "" : void 0;
+    }
+    if (!result || typeof result === "string" && !result.trim()) {
+      return stdoutParser === "string" ? "" : void 0;
+    }
+    switch (stdoutParser) {
+      case "json": {
+        try {
+          return JSON.parse(result);
+        } catch (parseError) {
+          if (throwOnError) {
+            throw new Error(
+              `Failed to parse JSON output: ${parseError.message}`
+            );
+          }
+          return void 0;
+        }
+      }
+      case "number": {
+        const num = parseFloat(result.trim());
+        if (isNaN(num)) {
+          if (throwOnError) {
+            throw new Error(`Failed to parse number from output: ${result}`);
+          }
+          return void 0;
+        }
+        return num;
+      }
+      case "string":
+      default:
+        return result;
+    }
+  } catch (error) {
+    if (!throwOnError) {
+      return void 0;
+    }
+    if (error.stderr) {
+      throw new Error(error.stderr.toString());
+    }
+    throw error;
+  }
+}
+function execString(command, options = {}) {
+  return exec(command, { ...options, stdoutParser: "string" });
+}
+function execJson(command, options = {}) {
+  return exec(command, { ...options, stdoutParser: "json" });
+}
+function execNumber(command, options = {}) {
+  return exec(command, { ...options, stdoutParser: "number" });
+}
+
+
+
+
+
+
+exports.exec = exec; exports.execString = execString; exports.execJson = execJson; exports.execNumber = execNumber;

package/cjs/__chunks/QBNNK2WX.cjs

@@ -0,0 +1,52 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/commands/doppler/schema.js
+var _zod = require('zod');
+var dopplerCommandOptionsSchema = _zod.z.object({
+  action: _zod.z.enum(["download", "upload"], {
+    errorMap: () => ({
+      message: "Action must be either 'download' or 'upload'"
+    })
+  }).describe("Action to perform: download or upload configurations"),
+  environment: _zod.z.string().optional().default("dev").describe(
+    'Environment configuration to process (e.g., dev, stg, prd, or "all" for all configs)'
+  ),
+  verbose: _zod.z.boolean().optional().default(false).describe("Enable verbose logging for detailed error information"),
+  help: _zod.z.boolean().optional().default(false).describe("Display help for command")
+});
+var dopplerCommandMetadata = {
+  name: "doppler",
+  description: `Manage Doppler configurations
+
+Subcommands:
+  download  Download configurations from Doppler to local .env files
+  upload    Upload local .env files to Doppler (with confirmation prompt)
+
+Examples:
+  $ @mtndev/cli doppler download              # Download dev config to .env.dev
+  $ @mtndev/cli doppler download -e all       # Download all configs
+  $ @mtndev/cli doppler download -e stg       # Download staging config
+  $ @mtndev/cli doppler upload                # Upload .env.dev to Doppler
+  $ @mtndev/cli doppler upload -e prd         # Upload production config`,
+  options: {
+    environment: {
+      description: dopplerCommandOptionsSchema.shape.environment.description,
+      default: "dev",
+      alias: "t"
+    },
+    // Global options are included here for help display
+    verbose: {
+      description: dopplerCommandOptionsSchema.shape.verbose.description,
+      default: false,
+      alias: "v"
+    },
+    help: {
+      description: dopplerCommandOptionsSchema.shape.help.description,
+      default: false,
+      alias: "h"
+    }
+  }
+};
+
+
+
+
+exports.dopplerCommandOptionsSchema = dopplerCommandOptionsSchema; exports.dopplerCommandMetadata = dopplerCommandMetadata;

package/cjs/__chunks/WNJ3ZYLI.cjs

@@ -0,0 +1 @@
+"use strict";

package/cjs/commands/doppler/handler.cjs

@@ -0,0 +1,9 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _HFSXD6YEcjs = require('../../__chunks/HFSXD6YE.cjs');
+require('../../__chunks/EMMC33QA.cjs');
+require('../../__chunks/NIMXXHJQ.cjs');
+require('../../__chunks/QBNNK2WX.cjs');
+
+
+exports.dopplerCommand = _HFSXD6YEcjs.dopplerCommand;

package/cjs/commands/doppler/handler.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Main doppler command handler
+ * @param {unknown} options - Command options (will be validated)
+ */
+export function dopplerCommand(options: unknown): Promise<void>;

package/cjs/commands/doppler/index.cjs

@@ -0,0 +1,41 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});require('../../__chunks/WNJ3ZYLI.cjs');
+
+
+var _HFSXD6YEcjs = require('../../__chunks/HFSXD6YE.cjs');
+
+
+
+
+
+
+
+
+
+var _EMMC33QAcjs = require('../../__chunks/EMMC33QA.cjs');
+
+
+
+
+
+var _NIMXXHJQcjs = require('../../__chunks/NIMXXHJQ.cjs');
+
+
+
+var _QBNNK2WXcjs = require('../../__chunks/QBNNK2WX.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.checkDependencies = _EMMC33QAcjs.checkDependencies; exports.createDiff = _EMMC33QAcjs.createDiff; exports.dopplerCommand = _HFSXD6YEcjs.dopplerCommand; exports.dopplerCommandMetadata = _QBNNK2WXcjs.dopplerCommandMetadata; exports.dopplerCommandOptionsSchema = _QBNNK2WXcjs.dopplerCommandOptionsSchema; exports.downloadConfigs = _EMMC33QAcjs.downloadConfigs; exports.exec = _NIMXXHJQcjs.exec; exports.execDoppler = _EMMC33QAcjs.execDoppler; exports.execJson = _NIMXXHJQcjs.execJson; exports.execNumber = _NIMXXHJQcjs.execNumber; exports.execString = _NIMXXHJQcjs.execString; exports.getConfigs = _EMMC33QAcjs.getConfigs; exports.normalizeEscapeSequences = _EMMC33QAcjs.normalizeEscapeSequences; exports.promptConfirmation = _EMMC33QAcjs.promptConfirmation; exports.uploadConfigs = _EMMC33QAcjs.uploadConfigs;

package/cjs/commands/doppler/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./handler.js";
+export * from "./schema.js";
+export * from "./utils.js";

package/cjs/commands/doppler/schema.cjs

@@ -0,0 +1,8 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _QBNNK2WXcjs = require('../../__chunks/QBNNK2WX.cjs');
+
+
+
+exports.dopplerCommandMetadata = _QBNNK2WXcjs.dopplerCommandMetadata; exports.dopplerCommandOptionsSchema = _QBNNK2WXcjs.dopplerCommandOptionsSchema;

package/cjs/commands/doppler/schema.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Zod schema for doppler command-specific options
+ * Global options (verbose, help) are inherited from globalOptionsSchema
+ */
+export const dopplerCommandOptionsSchema: z.ZodObject<{
+    action: z.ZodEnum<["download", "upload"]>;
+    environment: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    verbose: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    help: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    action: "download" | "upload";
+    environment: string;
+    verbose: boolean;
+    help: boolean;
+}, {
+    action: "download" | "upload";
+    environment?: string | undefined;
+    verbose?: boolean | undefined;
+    help?: boolean | undefined;
+}>;
+export namespace dopplerCommandMetadata {
+    let name: string;
+    let description: string;
+    namespace options {
+        namespace environment {
+            let description_1: string | undefined;
+            export { description_1 as description };
+            let _default: string;
+            export { _default as default };
+            export let alias: string;
+        }
+        namespace verbose {
+            let description_2: string | undefined;
+            export { description_2 as description };
+            let _default_1: boolean;
+            export { _default_1 as default };
+            let alias_1: string;
+            export { alias_1 as alias };
+        }
+        namespace help {
+            let description_3: string | undefined;
+            export { description_3 as description };
+            let _default_2: boolean;
+            export { _default_2 as default };
+            let alias_2: string;
+            export { alias_2 as alias };
+        }
+    }
+}
+import { z } from "zod";

package/cjs/commands/doppler/utils/exec.cjs

@@ -0,0 +1,12 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+var _NIMXXHJQcjs = require('../../../__chunks/NIMXXHJQ.cjs');
+
+
+
+
+
+exports.exec = _NIMXXHJQcjs.exec; exports.execJson = _NIMXXHJQcjs.execJson; exports.execNumber = _NIMXXHJQcjs.execNumber; exports.execString = _NIMXXHJQcjs.execString;

package/cjs/commands/doppler/utils/exec.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @typedef {'silent' | 'verbose' | 'default'} VerbosityLevel
+ */
+/**
+ * @typedef {Object} ExecOptions
+ * @property {'string' | 'number' | 'json'} [stdoutParser='string'] - How to parse stdout
+ * @property {boolean} [throwOnError=true] - Whether to throw on error
+ * @property {VerbosityLevel} [verbosity='default'] - Output verbosity level
+ */
+/**
+ * Execute a command and parse the output
+ * @param {string} command - Command to execute
+ * @param {import('child_process').ExecSyncOptions & ExecOptions} [options={}] - Execution options (inherits all execSync options + custom options)
+ * @returns {string | number | any} - Parsed output based on stdoutParser
+ */
+export function exec(command: string, options?: import("child_process").ExecSyncOptions & ExecOptions): string | number | any;
+/**
+ * Execute a command with string output
+ * @param {string} command - Command to execute
+ * @param {import('child_process').ExecSyncOptions & ExecOptions} [options] - Execution options
+ * @returns {string}
+ */
+export function execString(command: string, options?: import("child_process").ExecSyncOptions & ExecOptions): string;
+/**
+ * Execute a command with JSON output
+ * @param {string} command - Command to execute
+ * @param {import('child_process').ExecSyncOptions & ExecOptions} [options] - Execution options
+ * @returns {any}
+ */
+export function execJson(command: string, options?: import("child_process").ExecSyncOptions & ExecOptions): any;
+/**
+ * Execute a command with number output
+ * @param {string} command - Command to execute
+ * @param {import('child_process').ExecSyncOptions & ExecOptions} [options] - Execution options
+ * @returns {number}
+ */
+export function execNumber(command: string, options?: import("child_process").ExecSyncOptions & ExecOptions): number;
+export type VerbosityLevel = "silent" | "verbose" | "default";
+export type ExecOptions = {
+    /**
+     * - How to parse stdout
+     */
+    stdoutParser?: "string" | "number" | "json" | undefined;
+    /**
+     * - Whether to throw on error
+     */
+    throwOnError?: boolean | undefined;
+    /**
+     * - Output verbosity level
+     */
+    verbosity?: VerbosityLevel | undefined;
+};

package/cjs/commands/doppler/utils.cjs

@@ -0,0 +1,30 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+var _EMMC33QAcjs = require('../../__chunks/EMMC33QA.cjs');
+
+
+
+
+
+var _NIMXXHJQcjs = require('../../__chunks/NIMXXHJQ.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.checkDependencies = _EMMC33QAcjs.checkDependencies; exports.createDiff = _EMMC33QAcjs.createDiff; exports.downloadConfigs = _EMMC33QAcjs.downloadConfigs; exports.exec = _NIMXXHJQcjs.exec; exports.execDoppler = _EMMC33QAcjs.execDoppler; exports.execJson = _NIMXXHJQcjs.execJson; exports.execNumber = _NIMXXHJQcjs.execNumber; exports.execString = _NIMXXHJQcjs.execString; exports.getConfigs = _EMMC33QAcjs.getConfigs; exports.normalizeEscapeSequences = _EMMC33QAcjs.normalizeEscapeSequences; exports.promptConfirmation = _EMMC33QAcjs.promptConfirmation; exports.uploadConfigs = _EMMC33QAcjs.uploadConfigs;

package/cjs/commands/doppler/utils.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Execute a doppler command and return the result
+ * @param {string[]} args - Command arguments
+ * @param {'string' | 'json'} parser - How to parse the output
+ * @param {boolean} silent - Suppress output
+ * @param {boolean} verbose - Show verbose output
+ * @returns {string | any}
+ */
+export function execDoppler(args: string[], parser?: "string" | "json", silent?: boolean, verbose?: boolean): string | any;
+/**
+ * Check if doppler CLI is installed and configured
+ * @param {boolean} verbose - Show verbose output
+ */
+export function checkDependencies(verbose?: boolean): void;
+/**
+ * Get list of configurations based on environment parameter
+ * @param {string} environment - Environment name ('all', 'dev', 'stg', 'prd', etc.)
+ * @param {boolean} verbose - Show verbose output
+ * @returns {string[]}
+ */
+export function getConfigs(environment: string, verbose?: boolean): string[];
+/**
+ * Normalize escape sequences in file content
+ * @param {string} content - File content
+ * @returns {string}
+ */
+export function normalizeEscapeSequences(content: string): string;
+/**
+ * Create a unified diff between two strings
+ * @param {string} oldContent - Original content
+ * @param {string} newContent - New content
+ * @returns {string[]}
+ */
+export function createDiff(oldContent: string, newContent: string): string[];
+/**
+ * Prompt user for confirmation
+ * @param {string} message - Prompt message
+ * @returns {Promise<boolean>}
+ */
+export function promptConfirmation(message: string): Promise<boolean>;
+/**
+ * Download configurations from Doppler
+ * @param {{
+ * verbose: boolean;
+ * environment: string;
+ * }} options - Options for downloading configurations
+ */
+export function downloadConfigs(options: {
+    verbose: boolean;
+    environment: string;
+}): Promise<void>;
+/**
+ * Upload configurations to Doppler
+ * @param {{
+ * environment: string;
+ * verbose: boolean;
+ * }} options - Options for uploading configurations
+ */
+export function uploadConfigs(options: {
+    environment: string;
+    verbose: boolean;
+}): Promise<void>;
+export type VerbosityLevel = import("./utils/exec.js").VerbosityLevel;
+export type ExecOptions = import("./utils/exec.js").ExecOptions;
+import { exec } from "./utils/exec.js";
+import { execString } from "./utils/exec.js";
+import { execJson } from "./utils/exec.js";
+import { execNumber } from "./utils/exec.js";
+export { exec, execString, execJson, execNumber };

package/cjs/commands/icons/handler.cjs

@@ -0,0 +1,8 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _INFOPAHNcjs = require('../../__chunks/INFOPAHN.cjs');
+require('../../__chunks/4SFWHCB3.cjs');
+require('../../__chunks/J36P6UNE.cjs');
+
+
+exports.iconsCommand = _INFOPAHNcjs.iconsCommand;

package/cjs/commands/icons/handler.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Main icons command handler
+ * @param {unknown} options - Command options (will be validated)
+ */
+export function iconsCommand(options: unknown): Promise<void>;