@mtndev/cli 1.0.0 → 2.0.0

package/cjs/commands/index.cjs

@@ -1,7 +1,57 @@
 #!/usr/bin/env node
 "use strict"; function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 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 _FFFTVBURcjs = require('../__chunks/FFFTVBUR.cjs');
+var _ZMDIOZPTcjs = require('../__chunks/ZMDIOZPT.cjs');
+
+
+var _AZEB4H4Icjs = require('../__chunks/AZEB4H4I.cjs');
+require('../__chunks/FU4VP2LN.cjs');
+require('../__chunks/WHGN5PZI.cjs');
+require('../__chunks/B5ENMOCD.cjs');
+require('../__chunks/G5K4PVIL.cjs');
+require('../__chunks/TNSRDJPR.cjs');
+require('../__chunks/NLKJIUEX.cjs');
+require('../__chunks/X26XY2N6.cjs');
+require('../__chunks/BDU2UCE5.cjs');
+require('../__chunks/KU76LC42.cjs');
+require('../__chunks/UWHPE2GI.cjs');
+require('../__chunks/3BY5Y4W7.cjs');
+require('../__chunks/N5MXFOQZ.cjs');
+require('../__chunks/S3LVCWPN.cjs');
+require('../__chunks/T2A7TN4F.cjs');
+require('../__chunks/RPVAXPJ4.cjs');
+require('../__chunks/LXOOJR2R.cjs');
+require('../__chunks/XMKOKRXZ.cjs');
+require('../__chunks/LIKQ3SI4.cjs');
+require('../__chunks/LHE24ECK.cjs');
+require('../__chunks/SBBNW2BF.cjs');
+require('../__chunks/3T2LXW7J.cjs');
+require('../__chunks/FM5MVRQF.cjs');
+require('../__chunks/JSL2JDMW.cjs');
+require('../__chunks/2FSYDFUV.cjs');
+require('../__chunks/LFDSHANP.cjs');
+require('../__chunks/4XT5JEAS.cjs');
+require('../__chunks/WBOQ6AUN.cjs');
+require('../__chunks/B6XM5KSF.cjs');
+require('../__chunks/BLMSMR5E.cjs');
+
+
+var _DTQ2LB3Icjs = require('../__chunks/DTQ2LB3I.cjs');
+require('../__chunks/R3GUC7O7.cjs');
+require('../__chunks/3NOHGUCF.cjs');
+require('../__chunks/XTJPQ3EX.cjs');
+require('../__chunks/TKNNDDIB.cjs');
+require('../__chunks/YRHFKTW2.cjs');
+require('../__chunks/GUL36IFZ.cjs');
+require('../__chunks/NT2XXAI6.cjs');
+require('../__chunks/N7D56LPP.cjs');
+require('../__chunks/WOYF2L6T.cjs');
+require('../__chunks/W6K7BV74.cjs');
+require('../__chunks/LXDF5QVZ.cjs');
+require('../__chunks/3A5ZYU5M.cjs');
+require('../__chunks/K4QNHRTP.cjs');
+require('../__chunks/H74JSDBU.cjs');
+require('../__chunks/NWZGFHKH.cjs');
 require('../__chunks/B2KFW7T7.cjs');
 
 
@@ -10,48 +60,80 @@ require('../__chunks/4SFWHCB3.cjs');
 
 
 var _J36P6UNEcjs = require('../__chunks/J36P6UNE.cjs');
-require('../__chunks/WNJ3ZYLI.cjs');
+require('../__chunks/GZMTNK5N.cjs');
 
 
-var _YCCIX4ZQcjs = require('../__chunks/YCCIX4ZQ.cjs');
-require('../__chunks/EMMC33QA.cjs');
+var _GU3R54MKcjs = require('../__chunks/GU3R54MK.cjs');
+require('../__chunks/NFXQNOQH.cjs');
+require('../__chunks/JB7T7PKQ.cjs');
+require('../__chunks/CMUD7LLN.cjs');
 require('../__chunks/NIMXXHJQ.cjs');
 
 
-var _FEZT3HUTcjs = require('../__chunks/FEZT3HUT.cjs');
+var _FRHST54Jcjs = require('../__chunks/FRHST54J.cjs');
 
 // src/commands/index.js
 var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
 var _commander = require('commander');
 function displayWelcomeMessage() {
   console.log(_chalk2.default.bold.blue("\n\u{1F680} @mtndev/cli"));
-  console.log(_chalk2.default.gray(`   ${_FFFTVBURcjs.globalCommandsMetadata.description}
+  console.log(_chalk2.default.gray(`   ${_ZMDIOZPTcjs.globalCommandsMetadata.description}
 `));
 }
 displayWelcomeMessage();
-_commander.program.name(_FFFTVBURcjs.globalCommandsMetadata.name).description(_FFFTVBURcjs.globalCommandsMetadata.description).version(_FFFTVBURcjs.globalCommandsMetadata.version).option(
-  `-${_FFFTVBURcjs.globalCommandsMetadata.options.verbose.alias}, --verbose`,
-  _FFFTVBURcjs.globalCommandsMetadata.options.verbose.description,
-  _FFFTVBURcjs.globalCommandsMetadata.options.verbose.default
-);
-_commander.program.command("doppler <action>").description(_FEZT3HUTcjs.dopplerCommandMetadata.description).option(
-  `-${_FEZT3HUTcjs.dopplerCommandMetadata.options.environment.alias}, --environment <env>`,
-  _FEZT3HUTcjs.dopplerCommandMetadata.options.environment.description,
-  _FEZT3HUTcjs.dopplerCommandMetadata.options.environment.default
+_commander.program.name(_ZMDIOZPTcjs.globalCommandsMetadata.name).description(_ZMDIOZPTcjs.globalCommandsMetadata.description).version(_ZMDIOZPTcjs.globalCommandsMetadata.version).option(
+  `-${_ZMDIOZPTcjs.globalCommandsMetadata.options.verbose.alias}, --verbose`,
+  _ZMDIOZPTcjs.globalCommandsMetadata.options.verbose.description,
+  _ZMDIOZPTcjs.globalCommandsMetadata.options.verbose.default
+).configureHelp({
+  subcommandDescription: (cmd) => {
+    const desc = cmd.summary() || cmd.description().split("\n")[0] || "";
+    return desc + "\n";
+  }
+});
+_commander.program.command("doppler [action]").summary("Manage Doppler configurations").description(_FRHST54Jcjs.dopplerCommandMetadata.description).option(
+  `-${_FRHST54Jcjs.dopplerCommandMetadata.options.environments.alias}, --environments <envs>`,
+  _FRHST54Jcjs.dopplerCommandMetadata.options.environments.description
+).option(`--from <project>`, _FRHST54Jcjs.dopplerCommandMetadata.options.from.description).option(`--to <project>`, _FRHST54Jcjs.dopplerCommandMetadata.options.to.description).option(
+  `-${_FRHST54Jcjs.dopplerCommandMetadata.options.force.alias}, --force`,
+  _FRHST54Jcjs.dopplerCommandMetadata.options.force.description,
+  _FRHST54Jcjs.dopplerCommandMetadata.options.force.default
+).option(
+  `-${_FRHST54Jcjs.dopplerCommandMetadata.options.project.alias}, --project <project>`,
+  _FRHST54Jcjs.dopplerCommandMetadata.options.project.description
+).option(
+  `--environment <env>`,
+  _FRHST54Jcjs.dopplerCommandMetadata.options.environment.description
+).option(
+  `-${_FRHST54Jcjs.dopplerCommandMetadata.options.config.alias}, --config <config>`,
+  _FRHST54Jcjs.dopplerCommandMetadata.options.config.description
+).option(`--name <name>`, _FRHST54Jcjs.dopplerCommandMetadata.options.name.description).option(`--value <value>`, _FRHST54Jcjs.dopplerCommandMetadata.options.value.description).option(
+  `-${_FRHST54Jcjs.dopplerCommandMetadata.options.yes.alias}, --yes`,
+  _FRHST54Jcjs.dopplerCommandMetadata.options.yes.description,
+  _FRHST54Jcjs.dopplerCommandMetadata.options.yes.default
 ).option(
-  `-${_FEZT3HUTcjs.dopplerCommandMetadata.options.help.alias}, --help`,
-  _FEZT3HUTcjs.dopplerCommandMetadata.options.help.description,
-  _FEZT3HUTcjs.dopplerCommandMetadata.options.help.default
+  `-${_FRHST54Jcjs.dopplerCommandMetadata.options.help.alias}, --help`,
+  _FRHST54Jcjs.dopplerCommandMetadata.options.help.description,
+  _FRHST54Jcjs.dopplerCommandMetadata.options.help.default
 ).action(async (action, options, cmd) => {
   const globalOptions = _optionalChain([cmd, 'access', _ => _.parent, 'optionalAccess', _2 => _2.opts, 'call', _3 => _3()]) || {};
-  await _YCCIX4ZQcjs.dopplerCommand.call(void 0, {
+  await _GU3R54MKcjs.dopplerCommand.call(void 0, {
     action,
+    environments: options.environments,
+    from: options.from,
+    to: options.to,
+    force: options.force,
+    project: options.project,
     environment: options.environment,
+    config: options.config,
+    name: options.name,
+    value: options.value,
+    yes: options.yes,
     verbose: globalOptions.verbose,
     help: options.help
   });
 });
-_commander.program.command("icons <input>").description(_J36P6UNEcjs.iconsCommandMetadata.description).option(
+_commander.program.command("icons <input>").summary("Generate app channel version icons with overlay text").description(_J36P6UNEcjs.iconsCommandMetadata.description).option(
   `-${_J36P6UNEcjs.iconsCommandMetadata.options.channels.alias}, --channels <channels>`,
   _J36P6UNEcjs.iconsCommandMetadata.options.channels.description,
   _J36P6UNEcjs.iconsCommandMetadata.options.channels.default
@@ -75,6 +157,8 @@ _commander.program.command("icons <input>").description(_J36P6UNEcjs.iconsComman
     help: options.help
   });
 });
+_AZEB4H4Icjs.registerAwsCommands.call(void 0, _commander.program);
+_DTQ2LB3Icjs.registerDbCommands.call(void 0, _commander.program);
 _commander.program.on("command:*", () => {
   _commander.program.help();
 });

package/cjs/commands/schema.cjs

@@ -1,8 +1,8 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
 
-var _FFFTVBURcjs = require('../__chunks/FFFTVBUR.cjs');
+var _ZMDIOZPTcjs = require('../__chunks/ZMDIOZPT.cjs');
 
 
 
-exports.globalCommandsMetadata = _FFFTVBURcjs.globalCommandsMetadata; exports.globalOptionsSchema = _FFFTVBURcjs.globalOptionsSchema;
+exports.globalCommandsMetadata = _ZMDIOZPTcjs.globalCommandsMetadata; exports.globalOptionsSchema = _ZMDIOZPTcjs.globalOptionsSchema;

package/esm/__chunks/2FTTEFEK.js

@@ -0,0 +1,97 @@
+import {
+  defaultBody,
+  sendViaApi,
+  sendViaSmtp
+} from "./UXWY7BYE.js";
+import {
+  resolveProfile
+} from "./5GIUAFXL.js";
+import {
+  sendEmailOptionsSchema
+} from "./3BKWTHLJ.js";
+
+// src/commands/aws/ses/send-email/handler.js
+import chalk from "chalk";
+import { ZodError } from "zod";
+async function sendEmailCommand(options) {
+  try {
+    const parsed = sendEmailOptionsSchema.parse(options);
+    const {
+      to,
+      from,
+      subject,
+      transport,
+      region,
+      profile: profileOption,
+      accessKeyId,
+      dryRun,
+      verbose
+    } = parsed;
+    const body = parsed.body ?? defaultBody();
+    const profile = transport === "api" ? await resolveProfile({ profile: profileOption }) : profileOption;
+    console.log(chalk.blue("\n\u{1F4E7} SES send-email"));
+    console.log(chalk.gray(`   transport: ${transport}`));
+    console.log(chalk.gray(`   region:    ${region}`));
+    console.log(chalk.gray(`   from:      ${from}`));
+    console.log(chalk.gray(`   to:        ${to}`));
+    console.log(chalk.gray(`   subject:   ${subject}`));
+    if (verbose) {
+      console.log(chalk.gray(`   body:      ${body}`));
+    }
+    if (dryRun) {
+      console.log(chalk.yellow("\n[dry-run] No email sent."));
+      return;
+    }
+    const messageId = transport === "api" ? await sendViaApi({ to, from, subject, body, region, profile }) : await sendViaSmtp({ to, from, subject, body, region, accessKeyId });
+    console.log(
+      chalk.green(
+        `
+\u2705 Email sent${messageId ? ` (messageId: ${messageId})` : ""}.`
+      )
+    );
+  } catch (error) {
+    if (error instanceof ZodError) {
+      console.error(chalk.red("\n\u274C Invalid command options:"));
+      error.errors.forEach((err) => {
+        console.error(chalk.red(`   ${err.path.join(".")}: ${err.message}`));
+      });
+      process.exit(1);
+    }
+    const verbose = (
+      /** @type {any} */
+      options?.verbose || false
+    );
+    console.error(chalk.red("\n\u274C send-email failed:"));
+    if (error instanceof Error) {
+      console.error(chalk.red(`   ${error.message}`));
+      if (verbose && error.stack) {
+        console.error(chalk.gray("\nStack trace:"));
+        console.error(chalk.gray(error.stack));
+      }
+    } else {
+      console.error(chalk.red(`   ${String(error)}`));
+    }
+    console.error(chalk.yellow("\n\u{1F4A1} Troubleshooting tips:"));
+    console.error(
+      chalk.yellow("   \u2022 The sender address must be verified in SES")
+    );
+    console.error(
+      chalk.yellow(
+        "   \u2022 New SES accounts are sandboxed \u2014 recipients must also be verified"
+      )
+    );
+    console.error(
+      chalk.yellow(
+        "   \u2022 For smtp transport, set SES_SMTP_USER and SES_SMTP_PASSWORD"
+      )
+    );
+    console.error(
+      chalk.yellow("   \u2022 Use --verbose for detailed error information\n")
+    );
+    process.exit(1);
+  }
+}
+
+export {
+  sendEmailCommand
+};

package/esm/__chunks/33UYMUQD.js

@@ -0,0 +1,338 @@
+import {
+  DEFAULT_TTL
+} from "./IEOGAQYI.js";
+import {
+  runAws
+} from "./FNXUONAV.js";
+
+// src/commands/aws/route53/add-record/utils.js
+function bareHostedZoneId(rawId) {
+  return rawId.replace(/^\/hostedzone\//, "");
+}
+function withTrailingDot(name) {
+  const trimmed = name.trim();
+  if (trimmed === "") {
+    return trimmed;
+  }
+  return trimmed.endsWith(".") ? trimmed : `${trimmed}.`;
+}
+function withoutTrailingDot(name) {
+  return name.endsWith(".") ? name.slice(0, -1) : name;
+}
+function listHostedZones(params) {
+  const { profile, verbose } = params;
+  const data = runAws({
+    profile,
+    args: ["route53", "list-hosted-zones"],
+    verbose
+  });
+  const zones = [];
+  for (const zone of data.HostedZones ?? []) {
+    const id = bareHostedZoneId(String(zone.Id ?? ""));
+    const name = withTrailingDot(String(zone.Name ?? ""));
+    if (!id || !name) {
+      continue;
+    }
+    zones.push({
+      id,
+      name,
+      privateZone: Boolean(zone.Config?.PrivateZone),
+      recordCount: Number(zone.ResourceRecordSetCount ?? 0)
+    });
+  }
+  return zones.sort((a, b) => a.name.localeCompare(b.name));
+}
+function findHostedZone(params) {
+  const { zones, zoneInput } = params;
+  const input = zoneInput.trim();
+  if (!input) {
+    return null;
+  }
+  const bareId = bareHostedZoneId(input);
+  const byId = zones.find((zone) => zone.id === bareId);
+  if (byId) {
+    return byId;
+  }
+  const normalized = withTrailingDot(input).toLowerCase();
+  const matches = zones.filter(
+    (zone) => zone.name.toLowerCase() === normalized
+  );
+  if (matches.length === 1) {
+    return matches[0] ?? null;
+  }
+  if (matches.length > 1) {
+    return matches.find((zone) => !zone.privateZone) ?? matches[0] ?? null;
+  }
+  return null;
+}
+function hostedZoneLabel(zone) {
+  const visibility = zone.privateZone ? "private" : "public";
+  return `${withoutTrailingDot(zone.name)}  (${zone.id}, ${visibility}, ${zone.recordCount} records)`;
+}
+function resolveRecordName(params) {
+  const { nameInput, zoneName } = params;
+  const zoneFqdn = withTrailingDot(zoneName);
+  const raw = nameInput.trim();
+  if (raw === "" || raw === "@") {
+    return zoneFqdn;
+  }
+  const asFqdn = withTrailingDot(raw);
+  const zoneLower = zoneFqdn.toLowerCase();
+  if (asFqdn.toLowerCase() === zoneLower) {
+    return zoneFqdn;
+  }
+  if (asFqdn.toLowerCase().endsWith(`.${zoneLower}`)) {
+    return asFqdn;
+  }
+  const relative = raw.replace(/\.$/, "");
+  return withTrailingDot(`${relative}.${withoutTrailingDot(zoneFqdn)}`);
+}
+function getRecordSetsAtName(params) {
+  const { profile, hostedZoneId, name, verbose } = params;
+  const targetName = withTrailingDot(name).toLowerCase();
+  let startRecordName = withTrailingDot(name);
+  let startRecordType;
+  let nextRecordIdentifier;
+  const collected = [];
+  for (let page = 0; page < 20; page += 1) {
+    const args = [
+      "route53",
+      "list-resource-record-sets",
+      "--hosted-zone-id",
+      hostedZoneId,
+      "--max-items",
+      "100"
+    ];
+    if (startRecordName) {
+      args.push("--start-record-name", startRecordName);
+    }
+    if (startRecordType) {
+      args.push("--start-record-type", startRecordType);
+    }
+    if (nextRecordIdentifier) {
+      args.push("--start-record-identifier", nextRecordIdentifier);
+    }
+    const data = runAws({ profile, args, verbose });
+    const sets = data.ResourceRecordSets ?? [];
+    for (const set of sets) {
+      const setName = withTrailingDot(String(set.Name ?? "")).toLowerCase();
+      if (setName === targetName) {
+        collected.push(normalizeRecordSet(set));
+        continue;
+      }
+      if (setName > targetName) {
+        return collected;
+      }
+    }
+    const truncated = data.IsTruncated === true;
+    if (!truncated) {
+      return collected;
+    }
+    startRecordName = data.NextRecordName ? String(data.NextRecordName) : startRecordName;
+    startRecordType = data.NextRecordType ? String(data.NextRecordType) : void 0;
+    nextRecordIdentifier = data.NextRecordIdentifier ? String(data.NextRecordIdentifier) : void 0;
+  }
+  return collected;
+}
+function getResourceRecordSet(params) {
+  const { type, ...rest } = params;
+  const targetType = type.toUpperCase();
+  const sets = getRecordSetsAtName(rest);
+  return sets.find((set) => set.type === targetType) ?? null;
+}
+function findCnameConflicts(params) {
+  const { existingSets, type } = params;
+  const upperType = type.toUpperCase();
+  return existingSets.filter((set) => {
+    if (set.type === upperType) {
+      return false;
+    }
+    return upperType === "CNAME" || set.type === "CNAME";
+  });
+}
+function normalizeRecordSet(set) {
+  const values = (set.ResourceRecords ?? []).map(
+    (record) => String(record.Value ?? "")
+  );
+  return {
+    name: withTrailingDot(String(set.Name ?? "")),
+    type: String(set.Type ?? "").toUpperCase(),
+    ttl: typeof set.TTL === "number" ? set.TTL : void 0,
+    values,
+    isAlias: Boolean(set.AliasTarget),
+    aliasTarget: set.AliasTarget ?? void 0
+  };
+}
+function formatValues(values) {
+  if (values.length === 0) {
+    return "(none)";
+  }
+  if (values.length === 1) {
+    return values[0] ?? "(none)";
+  }
+  return values.map((value) => `
+    - ${value}`).join("");
+}
+function normalizeRecordValue(params) {
+  const { type, value } = params;
+  const trimmed = value.trim();
+  if (type === "CNAME" || type === "NS" || type === "MX" || type === "SRV") {
+    if (type === "MX") {
+      const parts = trimmed.split(/\s+/);
+      if (parts.length >= 2) {
+        const priority = parts[0];
+        const exchange = parts.slice(1).join(" ");
+        return `${priority} ${withTrailingDot(exchange)}`;
+      }
+    }
+    if (type === "SRV") {
+      const parts = trimmed.split(/\s+/);
+      if (parts.length >= 4) {
+        const prefix = parts.slice(0, 3).join(" ");
+        const target = parts.slice(3).join(" ");
+        return `${prefix} ${withTrailingDot(target)}`;
+      }
+    }
+    return withTrailingDot(trimmed);
+  }
+  if (type === "TXT") {
+    if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+      return trimmed;
+    }
+    return `"${trimmed}"`;
+  }
+  return trimmed;
+}
+function planRecordChange(params) {
+  const { existing, newValue, mode = "replace" } = params;
+  if (!existing) {
+    return {
+      action: "create",
+      finalValues: [newValue],
+      summary: "Adding a new record (nothing exists at this name + type)."
+    };
+  }
+  if (existing.isAlias) {
+    return {
+      action: "overwrite",
+      finalValues: [newValue],
+      summary: "Overwriting an existing ALIAS record with a standard record set."
+    };
+  }
+  const alreadyPresent = existing.values.some(
+    (value) => value === newValue || value === `"${newValue}"`
+  );
+  if (alreadyPresent && mode !== "replace") {
+    return {
+      action: "noop",
+      finalValues: existing.values,
+      summary: "Record already has this value. Nothing to do."
+    };
+  }
+  if (alreadyPresent && mode === "replace" && existing.values.length === 1 && existing.values[0] === newValue) {
+    return {
+      action: "noop",
+      finalValues: existing.values,
+      summary: "Record already has exactly this value. Nothing to do."
+    };
+  }
+  if (mode === "append") {
+    return {
+      action: "append",
+      finalValues: [...existing.values, newValue],
+      summary: `Adding to the existing ${existing.type} record (${existing.values.length} value(s) \u2192 ${existing.values.length + 1}).`
+    };
+  }
+  return {
+    action: "overwrite",
+    finalValues: [newValue],
+    summary: existing.values.length === 1 ? `Overwriting existing value:
+    ${existing.values[0]}
+  \u2192 ${newValue}` : `Replacing ${existing.values.length} existing values with a single new value.`
+  };
+}
+function upsertResourceRecordSet(params) {
+  const { profile, hostedZoneId, name, type, ttl, values, verbose } = params;
+  const changeBatch = {
+    Comment: `mtn aws route53 add-record: ${type} ${name}`,
+    Changes: [
+      {
+        Action: "UPSERT",
+        ResourceRecordSet: {
+          Name: withTrailingDot(name),
+          Type: type,
+          TTL: ttl ?? DEFAULT_TTL,
+          ResourceRecords: values.map((value) => ({ Value: value }))
+        }
+      }
+    ]
+  };
+  const data = runAws({
+    profile,
+    args: [
+      "route53",
+      "change-resource-record-sets",
+      "--hosted-zone-id",
+      hostedZoneId,
+      "--change-batch",
+      JSON.stringify(changeBatch)
+    ],
+    verbose
+  });
+  return data.ChangeInfo ?? data;
+}
+function deleteResourceRecordSet(params) {
+  const { profile, hostedZoneId, record, verbose } = params;
+  const resourceRecordSet = {
+    Name: withTrailingDot(record.name),
+    Type: record.type
+  };
+  if (record.isAlias && record.aliasTarget) {
+    resourceRecordSet.AliasTarget = record.aliasTarget;
+  } else {
+    resourceRecordSet.TTL = record.ttl ?? DEFAULT_TTL;
+    resourceRecordSet.ResourceRecords = record.values.map((value) => ({
+      Value: value
+    }));
+  }
+  const changeBatch = {
+    Comment: `mtn aws route53 remove-record: ${record.type} ${record.name}`,
+    Changes: [
+      {
+        Action: "DELETE",
+        ResourceRecordSet: resourceRecordSet
+      }
+    ]
+  };
+  const data = runAws({
+    profile,
+    args: [
+      "route53",
+      "change-resource-record-sets",
+      "--hosted-zone-id",
+      hostedZoneId,
+      "--change-batch",
+      JSON.stringify(changeBatch)
+    ],
+    verbose
+  });
+  return data.ChangeInfo ?? data;
+}
+
+export {
+  bareHostedZoneId,
+  withTrailingDot,
+  withoutTrailingDot,
+  listHostedZones,
+  findHostedZone,
+  hostedZoneLabel,
+  resolveRecordName,
+  getRecordSetsAtName,
+  getResourceRecordSet,
+  findCnameConflicts,
+  formatValues,
+  normalizeRecordValue,
+  planRecordChange,
+  upsertResourceRecordSet,
+  deleteResourceRecordSet
+};

package/esm/__chunks/3BKWTHLJ.js

@@ -0,0 +1,25 @@
+import {
+  profileField,
+  verboseField
+} from "./73BJG53F.js";
+
+// src/commands/aws/ses/send-email/schema.js
+import { z } from "zod";
+var sendEmailOptionsSchema = z.object({
+  to: z.string({ required_error: "--to <address> is required" }).describe("Recipient email address"),
+  from: z.string({ required_error: "--from <address> is required" }).describe("Verified SES sender email address"),
+  subject: z.string().optional().default("MTN CLI test email").describe("Email subject line"),
+  body: z.string().optional().describe("Email body (defaults to a timestamp and random token)"),
+  transport: z.enum(["api", "smtp"]).optional().default("api").describe("Send via the SES API (default) or SES SMTP"),
+  region: z.string().optional().default("us-east-1").describe("AWS region for the SES endpoint"),
+  profile: profileField,
+  accessKeyId: z.string().optional().describe(
+    "IAM access key ID used as the SMTP username (smtp transport only)"
+  ),
+  dryRun: z.boolean().optional().default(false).describe("Print the email payload without sending"),
+  verbose: verboseField
+});
+
+export {
+  sendEmailOptionsSchema
+};