@fragment-dev/cli 2026.9.9 → 2026.9.10-10

package/dist/{chunk-JZ773SXY.js → chunk-QUNR5ZC3.js}

@@ -1,13 +1,14 @@
 import {
   standardQueries
-} from "./chunk-4VYFUMLV.js";
+} from "./chunk-7GWSUHUD.js";
 import {
   InvalidGraphQlError
 } from "./chunk-ZMFGVGZP.js";
 import {
+  SYSTEM_PARAMETER_NAMES,
   getSchemaObjectParameters,
   getStructuralSubpaths
-} from "./chunk-PUON7HP5.js";
+} from "./chunk-FUUGVGYY.js";
 import {
   require_source
 } from "./chunk-XK2D2Z44.js";
@@ -26,6 +27,16 @@ var import_chalk = __toESM(require_source(), 1);
 var import_parser = __toESM(require_parser(), 1);
 var import_printer = __toESM(require_printer(), 1);
 import { statSync, existsSync } from "node:fs";
+
+// ../../libs/schema-validation/utils/paymentTypes.ts
+init_cjs_shims();
+var getRequiredPaymentParameters = (paymentType) => new Set(
+  getSchemaObjectParameters(paymentType, true).filter(
+    (name) => !SYSTEM_PARAMETER_NAMES.has(name)
+  )
+);
+
+// src/graphql.ts
 var getAccountParams = (accountPath, schema) => {
   const subpaths = getStructuralSubpaths(accountPath);
   return subpaths.flatMap(
@@ -106,6 +117,16 @@ var schemaToEntryDefinitions = ({
     ];
   });
 };
+var schemaToPaymentDefinitions = ({
+  schema
+}) => (schema.payments?.types ?? []).map((paymentType) => ({
+  paymentType: paymentType.type,
+  typeVersion: paymentType.typeVersion,
+  direction: paymentType.payment.direction,
+  // The same helper `createPayment` validates against, so the generated
+  // variables are exactly the parameters the API accepts.
+  parameters: Array.from(getRequiredPaymentParameters(paymentType))
+}));
 var camelCase = (value, delimiter) => {
   return value.split(delimiter).filter((x) => !!x).map((word, index) => {
     if (index === 0) {
@@ -188,25 +209,80 @@ __typename
 }
 ${OnErrorFragment}
 `;
+var PaymentFragment = `
+    ik
+    ledger {
+      id
+      ik
+    }
+    type
+    typeVersion
+    status
+    amount
+    mode
+    clientSecret
+    created
+`;
+var CreatePaymentFragment = `
+__typename
+... on CreatePaymentResult {
+  payment {
+    ${PaymentFragment}
+  }
+}
+${OnErrorFragment}
+`;
 var isValidGraphQlName = (name) => {
   return /^[a-zA-Z_]+[a-zA-Z0-9_]*$/.exec(name) !== null;
 };
-var generateGraphQlEntryType = (entryType, typeVersion) => {
-  const readableEntryType = camelCase(camelCase(entryType, "_"), "-").split("").map((ch, idx) => {
-    if (idx === 0) {
-      return ch.toUpperCase();
-    }
-    return ch;
-  }).join("").replace(/\s+/g, "_").replace(/\./g, "_").replace(/[^a-zA-Z0-9_]/g, "").replace(/^(\d)/, "_$1").concat(typeVersion && typeVersion > 1 ? `_v${typeVersion}` : "");
-  if (!isValidGraphQlName(readableEntryType)) {
+var toPascalCaseGraphQlName = (value) => camelCase(camelCase(value, "_"), "-").split("").map((ch, idx) => {
+  if (idx === 0) {
+    return ch.toUpperCase();
+  }
+  return ch;
+}).join("").replace(/\s+/g, "_").replace(/\./g, "_").replace(/[^a-zA-Z0-9_]/g, "").replace(/^(\d)/, "_$1");
+var versionSuffix = (typeVersion) => typeof typeVersion === "number" && typeVersion > 1 ? `_v${typeVersion}` : "";
+var OperationSubject = {
+  entry: "entry",
+  paymentType: "payment type"
+};
+var assertValidOperationName = ({
+  name,
+  subject,
+  sourceType
+}) => {
+  if (!isValidGraphQlName(name)) {
     throw new InvalidGraphQlError(
-      `Operation name ${readableEntryType} (for entry: ${import_chalk.default.yellow(
-        entryType
+      `Operation name ${name} (for ${subject}: ${import_chalk.default.yellow(
+        sourceType
       )}) is not a valid GraphQL name`
     );
   }
+};
+var generateGraphQlEntryType = (entryType, typeVersion) => {
+  const readableEntryType = toPascalCaseGraphQlName(entryType).concat(
+    versionSuffix(typeVersion)
+  );
+  assertValidOperationName({
+    name: readableEntryType,
+    subject: OperationSubject.entry,
+    sourceType: entryType
+  });
   return readableEntryType;
 };
+var generateGraphQlPaymentType = ({
+  paymentType,
+  direction,
+  typeVersion
+}) => {
+  const readablePaymentType = toPascalCaseGraphQlName(paymentType).concat(toPascalCaseGraphQlName(direction)).concat(versionSuffix(typeVersion));
+  assertValidOperationName({
+    name: readablePaymentType,
+    subject: OperationSubject.paymentType,
+    sourceType: paymentType
+  });
+  return readablePaymentType;
+};
 var getPredefinedParameters = (definition) => {
   const params = {};
   if (definition.method === "addLedgerEntry") {
@@ -306,13 +382,64 @@ var entryDefinitionToMutation = (definition) => {
     operationName
   };
 };
+var paymentPredefinedParameters = {
+  ik: "SafeString!",
+  ledgerIk: "SafeString!"
+};
+var paymentDefinitionToMutation = (definition) => {
+  const { paymentType, typeVersion, direction, parameters } = definition;
+  parameters.forEach((param) => {
+    if (!isValidGraphQlName(param)) {
+      throw new InvalidGraphQlError(
+        `Parameter name ${param} is not a valid GraphQL name`
+      );
+    }
+  });
+  const operationName = `CreatePayment${generateGraphQlPaymentType({
+    paymentType,
+    direction,
+    typeVersion
+  })}`;
+  const varArgs = [
+    ...Object.entries(paymentPredefinedParameters).map(
+      ([name, type]) => `$${name}: ${type}`
+    ),
+    ...parameters.filter(
+      (p) => !Object.prototype.hasOwnProperty.call(paymentPredefinedParameters, p)
+    ).map((p) => `$${p}: String!`)
+  ].join(",\n");
+  const command = [
+    `mutation ${operationName} (`,
+    `${varArgs}) {`,
+    `createPayment(`,
+    `ik: $ik,`,
+    `ledger: { ik: $ledgerIk },`,
+    `payment: {`,
+    `type: "${paymentType}",`,
+    `typeVersion: ${typeVersion},`
+  ];
+  if (parameters.length > 0) {
+    command.push(`parameters: {`);
+    command.push(parameters.map((p) => `${p}: $${p}`).join("\n"));
+    command.push(`}`);
+  }
+  command.push(`}) { ${CreatePaymentFragment} } }`);
+  return {
+    mutation: (0, import_printer.print)((0, import_parser.parse)(command.join(""))),
+    operationName
+  };
+};
 var generateQueriesFileContent = ({
   definitions,
+  paymentDefinitions,
   includeStandardQueries
 }) => {
-  const generatedCode = definitions.map(
-    (def) => entryDefinitionToMutation(def).mutation
-  );
+  const generatedCode = [
+    ...definitions.map((def) => entryDefinitionToMutation(def).mutation),
+    ...paymentDefinitions.map(
+      (def) => paymentDefinitionToMutation(def).mutation
+    )
+  ];
   if (includeStandardQueries) {
     generatedCode.push(standardQueries);
   }
@@ -321,16 +448,17 @@ var generateQueriesFileContent = ({
 };
 var generateQueryFiles = ({
   definitions,
+  paymentDefinitions,
   includeStandardQueries
 }) => {
-  const generatedCode = definitions.map((def) => {
-    const { operationName, mutation } = entryDefinitionToMutation(def);
-    return {
-      content: `${mutation}
+  const generatedCode = [
+    ...definitions.map((def) => entryDefinitionToMutation(def)),
+    ...paymentDefinitions.map((def) => paymentDefinitionToMutation(def))
+  ].map(({ operationName, mutation }) => ({
+    content: `${mutation}
 `,
-      fileName: `${operationName}.graphql`
-    };
-  });
+    fileName: `${operationName}.graphql`
+  }));
   if (includeStandardQueries) {
     const parsedStdQueries = (0, import_parser.parse)(standardQueries);
     parsedStdQueries.definitions.forEach((def) => {
@@ -366,11 +494,14 @@ var validateOutputName = ({
 
 export {
   schemaToEntryDefinitions,
+  schemaToPaymentDefinitions,
   camelCase,
   isValidGraphQlName,
   generateGraphQlEntryType,
+  generateGraphQlPaymentType,
   getPredefinedParameters,
   entryDefinitionToMutation,
+  paymentDefinitionToMutation,
   generateQueriesFileContent,
   generateQueryFiles,
   validateOutputName

package/dist/{chunk-2UUZOEA7.js → chunk-RILSVR74.js}

@@ -1,17 +1,31 @@
 import {
+  AccountConsistencyConfigSchema,
+  BaseChartOfAccounts,
+  ConsistencyConfigSchema,
+  PaymentEventKey,
+  PaymentEventKeySchema,
+  PaymentTypeDirection,
+  PaymentTypeDirectionSchema,
+  PostLinesAsSchema,
+  SYSTEM_LINE_AMOUNT,
+  SYSTEM_PARAMETER_NAMES,
+  SchemaEntryGroup,
+  SchemaLedgerEntityStatusSchema,
+  SchemaPaymentTypeStatusSchema,
+  SchemaTxMatchInput,
+  SystemLineKind,
+  SystemLineKindSchema,
   fillParams,
   getInstanceValueByAccountPath,
   getSchemaObjectParameters,
   getStructuralPath,
   getStructuralSubpaths,
   getSubpaths
-} from "./chunk-PUON7HP5.js";
+} from "./chunk-FUUGVGYY.js";
 import {
   BadRequestError,
   CurrencyMatchInputSchema,
-  CurrencyModeSchema,
   InternalError,
-  LedgerAccountTypeSchema,
   MAX_FREEFORM_TEXT_LENGTH,
   ParameterizedAmount,
   ParameterizedString,
@@ -23,7 +37,7 @@ import {
   mapValues_default,
   safe,
   z
-} from "./chunk-3AACKVGA.js";
+} from "./chunk-65EVYD2Y.js";
 import {
   __commonJS,
   __toESM,
@@ -4466,297 +4480,6 @@ var safeGetZodErrors = (schema, value, pathPrefix) => {
 // ../../libs/schema-validation/types.ts
 init_cjs_shims();
 
-// ../../libs/types/schemas.ts
-init_cjs_shims();
-
-// ../../libs/types/tx.ts
-init_cjs_shims();
-var SchemaTxMatchInput = z.object({
-  id: z.optional(ParameterizedString),
-  externalId: z.optional(ParameterizedString)
-});
-var txTypes = ["credit", "debit"];
-var TxTypeSchema = z.enum(txTypes);
-
-// ../../libs/types/schemas.ts
-var LedgerMigrationStatusSchema = z.enum([
-  "queued",
-  "started",
-  "failed",
-  "completed",
-  "skipped"
-]);
-var SafeRecordKey = z.string().refine((v2) => v2 !== "__proto__", "invalid parameter name");
-var ParametersSchema = z.record(
-  SafeRecordKey,
-  z.string({
-    invalid_type_error: "Invalid parameter type. All parameters must be string-encoded values."
-  })
-);
-var EntryParametersSchema = z.record(
-  SafeRecordKey,
-  z.union([
-    z.string({
-      invalid_type_error: "Invalid parameter type. Parameters must be string-encoded values or arrays of objects with string values."
-    }),
-    z.array(z.record(SafeRecordKey, z.string()))
-  ])
-);
-var ConsistencyModeSchema = z.enum(["strong", "eventual"]);
-var ConsistencyConfigSchema = (keys, extra) => {
-  const v2 = z.optional(ConsistencyModeSchema);
-  const schemaObject = Object.fromEntries(
-    keys.map((key) => [key, v2])
-  );
-  return z.object({ ...extra, ...schemaObject });
-};
-var GroupConsistencyConfig = z.object({
-  key: SafeStringSchema,
-  ownBalanceUpdates: ConsistencyModeSchema
-});
-var AccountConsistencyConfigSchema = z.object({
-  lines: z.optional(ConsistencyModeSchema),
-  ownBalanceUpdates: z.optional(ConsistencyModeSchema),
-  totalBalanceUpdates: z.optional(ConsistencyModeSchema),
-  groups: z.optional(z.array(GroupConsistencyConfig))
-});
-var SchemaCurrencyMatchInput = z.object({
-  customCurrencyId: z.string().optional(),
-  code: z.string()
-});
-var SchemaLinkTypeList = [
-  "IncreaseLink",
-  "UnitLink",
-  "CustomLink",
-  "StripeLink"
-];
-var SchemaLinkType = z.enum(SchemaLinkTypeList);
-var SchemaExternalAccountMatchInput = z.object({
-  linkType: SchemaLinkType.optional(),
-  id: z.string().optional(),
-  externalId: z.string().optional(),
-  linkId: z.string().optional()
-});
-var SchemaPaymentInput = z.object({
-  enabled: z.boolean()
-});
-var SchemaLedgerEntityStatusSchema = z.enum([
-  "active",
-  "disabled",
-  "archived"
-]);
-var BaseSchemaLedgerAccountInput = z.lazy(
-  () => z.object({
-    key: z.string(),
-    name: z.string().optional(),
-    type: LedgerAccountTypeSchema.optional(),
-    currency: SchemaCurrencyMatchInput.optional(),
-    currencyMode: CurrencyModeSchema.optional(),
-    template: z.boolean().optional(),
-    clearing: z.boolean().optional(),
-    children: z.array(BaseSchemaLedgerAccountInput).optional(),
-    linkedAccount: SchemaExternalAccountMatchInput.optional(),
-    payment: SchemaPaymentInput.optional(),
-    consistencyConfig: AccountConsistencyConfigSchema.optional(),
-    status: SchemaLedgerEntityStatusSchema.optional()
-  })
-);
-var BaseChartOfAccounts = z.object({
-  defaultConsistencyConfig: AccountConsistencyConfigSchema.optional(),
-  defaultCurrency: z.optional(CurrencyMatchInputSchema),
-  defaultCurrencyMode: CurrencyModeSchema.optional(),
-  accounts: z.array(BaseSchemaLedgerAccountInput)
-});
-var SchemaCondition = z.object({
-  ownBalance: z.object({
-    eq: z.string().optional(),
-    lte: z.string().optional(),
-    gte: z.string().optional()
-  }).optional(),
-  totalBalance: z.object({
-    eq: z.string().optional(),
-    lte: z.string().optional(),
-    gte: z.string().optional()
-  }).optional()
-});
-var PostLinesAsSchema = z.enum([
-  "raw_lines",
-  "net_amounts",
-  "skip_zero_lines"
-]);
-var BaseSchemaLedgerEntryConditionInput = z.object({
-  account: z.object({ path: z.string() }).optional(),
-  postcondition: SchemaCondition.optional(),
-  precondition: SchemaCondition.optional(),
-  currency: SchemaCurrencyMatchInput.optional(),
-  repeated: z.object({
-    key: SafeStringSchema.refine((k2) => k2.trim().length >= 1, {
-      message: "repeated.key cannot be empty"
-    })
-  }).optional()
-});
-var BaseSchemaLedgerLineTagInput = z.object({
-  key: z.string(),
-  value: z.string()
-});
-var BaseSchemaLedgerEntryLineInput = z.object({
-  account: z.object({ path: z.string() }).optional(),
-  amount: z.string().optional(),
-  key: z.string(),
-  currency: SchemaCurrencyMatchInput.optional(),
-  description: z.string().optional(),
-  tx: SchemaTxMatchInput.optional(),
-  tags: z.array(BaseSchemaLedgerLineTagInput).optional(),
-  repeated: z.object({
-    key: SafeStringSchema.refine((k2) => k2.trim().length >= 1, {
-      message: "repeated.key cannot be empty"
-    })
-  }).optional()
-});
-var BaseSchemaLedgerEntryInput = z.object({
-  type: z.string(),
-  typeVersion: z.number().int().optional(),
-  description: z.string().optional(),
-  conditions: z.array(BaseSchemaLedgerEntryConditionInput).optional(),
-  lines: z.array(BaseSchemaLedgerEntryLineInput).optional(),
-  parameters: z.record(SafeRecordKey, z.string()).optional(),
-  tags: z.array(
-    z.object({
-      key: z.string(),
-      value: z.string()
-    })
-  ).optional(),
-  groups: z.array(
-    z.object({
-      key: SafeStringSchema,
-      value: z.string()
-    })
-  ).optional(),
-  status: SchemaLedgerEntityStatusSchema.optional(),
-  postLinesAs: PostLinesAsSchema.optional()
-});
-var BaseLedgerEntries = z.object({
-  types: z.array(BaseSchemaLedgerEntryInput)
-});
-var PaymentEventKey = {
-  /** Exit from the payer not yet having supplied a payment method at checkout. */
-  needs_payment_method_to_processing: "needs_payment_method_to_processing",
-  processing_to_settled: "processing_to_settled"
-};
-var PaymentEventKeySchema = z.nativeEnum(PaymentEventKey);
-var PaymentTypeDirection = {
-  payin: "payin",
-  payout: "payout"
-};
-var PaymentTypeDirectionSchema = z.nativeEnum(PaymentTypeDirection);
-var SystemLineKind = {
-  payment_settlement_line: "payment_settlement_line",
-  payment_fee_line: "payment_fee_line"
-};
-var SystemLineKindSchema = z.nativeEnum(SystemLineKind);
-var SystemLineParameterName = {
-  payment_settlement_line: "settled_amount",
-  payment_fee_line: "fragment_fee_amount"
-};
-var SYSTEM_LINE_AMOUNT = {
-  [SystemLineKind.payment_settlement_line]: `{{${SystemLineParameterName.payment_settlement_line}}}`,
-  [SystemLineKind.payment_fee_line]: `-{{${SystemLineParameterName.payment_fee_line}}}`
-};
-var SYSTEM_PARAMETER_NAMES = new Set(
-  Object.values(SystemLineParameterName)
-);
-var BaseSchemaPaymentInput = z.object({
-  amount: z.string(),
-  direction: PaymentTypeDirectionSchema
-});
-var BaseSchemaPaymentEntryLineInput = BaseSchemaLedgerEntryLineInput.pick({
-  key: true,
-  currency: true,
-  description: true
-}).extend({
-  account: z.object({ path: z.string() }),
-  amount: z.string(),
-  system: SystemLineKindSchema.optional()
-});
-var BaseSchemaPaymentEntryInput = z.object({
-  description: z.string().optional(),
-  lines: z.array(BaseSchemaPaymentEntryLineInput)
-});
-var SchemaPaymentTypeStatusSchema = z.enum(["active"]);
-var BaseSchemaPaymentTypeInput = z.object({
-  type: z.string(),
-  typeVersion: z.number().int(),
-  status: SchemaPaymentTypeStatusSchema,
-  payment: BaseSchemaPaymentInput,
-  accounting: z.object({
-    needs_payment_method_to_processing: BaseSchemaPaymentEntryInput.optional(),
-    processing_to_settled: BaseSchemaPaymentEntryInput
-  })
-});
-var BaseSchemaPayments = z.object({
-  types: z.array(BaseSchemaPaymentTypeInput)
-});
-var SceneEntrySchema = z.object({
-  type: z.string(),
-  typeVersion: z.number().int().positive().optional(),
-  parameters: z.record(SafeRecordKey, z.string())
-});
-var ScenePaymentSchema = z.object({
-  ik: z.string(),
-  type: z.string(),
-  typeVersion: z.number().int().positive().optional(),
-  parameters: z.record(SafeRecordKey, z.string())
-});
-var SceneLedgerEventSchema = z.object({
-  eventType: z.literal("entry"),
-  entry: SceneEntrySchema
-});
-var ScenePaymentEventSchema = z.object({
-  eventType: z.literal("payment"),
-  payment: z.object({
-    ik: z.string(),
-    event: PaymentEventKeySchema
-  })
-});
-var SceneEventSchema = z.discriminatedUnion("eventType", [
-  SceneLedgerEventSchema,
-  ScenePaymentEventSchema
-]);
-var BaseScene = z.object({
-  name: z.string(),
-  events: z.array(SceneEventSchema),
-  payments: z.array(ScenePaymentSchema).optional()
-});
-var EntryKey = z.object({
-  type: SafeStringSchema,
-  typeVersion: z.number().int().positive()
-});
-var SchemaLedgerAccountMatchInput = z.object({
-  path: ParameterizedString
-});
-var GroupReconciliationParameters = z.object({
-  clearingAccountPath: SchemaLedgerAccountMatchInput
-});
-var SchemaEntryGroup = z.object({
-  key: SafeStringSchema,
-  description: z.string().optional(),
-  reconciliation: GroupReconciliationParameters.optional()
-});
-var BaseSchema = z.object({
-  name: z.string().optional(),
-  key: z.string(),
-  chartOfAccounts: BaseChartOfAccounts,
-  ledgerEntries: BaseLedgerEntries.optional(),
-  payments: BaseSchemaPayments.optional(),
-  groups: z.array(SchemaEntryGroup).optional(),
-  scenes: z.array(BaseScene).optional(),
-  consistencyConfig: z.optional(
-    z.object({
-      entries: ConsistencyModeSchema.optional()
-    })
-  )
-});
-
 // ../../libs/schema-validation/utils/transformers/coa.ts
 init_cjs_shims();
 
@@ -4874,7 +4597,7 @@ var validateDefaultCurrencySettings = ({
         message: `Default currency customCurrencyId cannot be parameterized`,
         path: ["defaultCurrency", "customCurrencyId"]
       });
-    } else if (!SchemaCurrencyMatchInput2.safeParse(defaultCurrency).success) {
+    } else if (!SchemaCurrencyMatchInput.safeParse(defaultCurrency).success) {
       if (defaultCurrency.code === "CUSTOM" && !defaultCurrency.customCurrencyId) {
         errors.push({
           message: `Must provide custom currency ID for custom currency`,
@@ -5195,7 +4918,7 @@ var validateAccountCurrency = ({
       path: [...path, "currency"]
     });
   }
-  if (currency && !SchemaCurrencyMatchInput2.safeParse(currency).success) {
+  if (currency && !SchemaCurrencyMatchInput.safeParse(currency).success) {
     if (currency.code === "CUSTOM" && !currency.customCurrencyId) {
       errors.push({
         message: `Must provide custom currency ID for custom currency (key: ${key}, name: ${name})`,
@@ -6508,7 +6231,7 @@ var validateLineCurrency = (currency, accountPath, accountPathToAccount, entryPa
       path: ["currency"]
     });
   }
-  if (currency && !SchemaCurrencyMatchInput2.safeParse(currency).success) {
+  if (currency && !SchemaCurrencyMatchInput.safeParse(currency).success) {
     if (currency.code === "CUSTOM" && !currency.customCurrencyId) {
       validationResults.push({
         message: `Line must provide custom currency ID for custom currency (Line key: ${lineKey}, entry: ${entryType})`,
@@ -7872,7 +7595,7 @@ var transformAndValidatePayments = ({
 };
 
 // ../../libs/schema-validation/types.ts
-var SchemaCurrencyMatchInput2 = z.object({
+var SchemaCurrencyMatchInput = z.object({
   customCurrencyId: ParameterizedString.optional(),
   code: ParameterizedString.refine(
     (str) => {
@@ -7953,7 +7676,7 @@ var SchemaLedgerLineInput = z.object({
   }),
   amount: ParameterizedAmount().optional(),
   key: SafeStringSchema,
-  currency: z.optional(SchemaCurrencyMatchInput2),
+  currency: z.optional(SchemaCurrencyMatchInput),
   description: ParameterizedString.optional(),
   tx: SchemaTxMatchInput.optional(),
   tags: z.array(SchemaLedgerLineTagInput).optional(),
@@ -8042,7 +7765,7 @@ var SchemaLedgerEntryConditionInput = z.object({
   }),
   postcondition: SchemaConditionInput.optional(),
   precondition: SchemaConditionInput.optional(),
-  currency: SchemaCurrencyMatchInput2.optional(),
+  currency: SchemaCurrencyMatchInput.optional(),
   repeated: z.object({
     key: SafeStringSchema.refine((k2) => k2.trim().length >= 1, {
       message: "repeated.key cannot be empty"

package/dist/commands/gen-graphql.js

@@ -1,13 +1,13 @@
 import {
   GenGraphQL
-} from "../chunk-ZPKRHWC3.js";
-import "../chunk-JZ773SXY.js";
-import "../chunk-4VYFUMLV.js";
+} from "../chunk-KJFWVDCE.js";
+import "../chunk-QUNR5ZC3.js";
+import "../chunk-7GWSUHUD.js";
 import "../chunk-ZMFGVGZP.js";
-import "../chunk-2UUZOEA7.js";
-import "../chunk-VYSP73KB.js";
-import "../chunk-PUON7HP5.js";
-import "../chunk-3AACKVGA.js";
+import "../chunk-RILSVR74.js";
+import "../chunk-J6HLIC77.js";
+import "../chunk-FUUGVGYY.js";
+import "../chunk-65EVYD2Y.js";
 import "../chunk-W33MLXYW.js";
 import "../chunk-34NLRFFT.js";
 import "../chunk-LFCNPXLH.js";

package/dist/commands/verify-schema.js

@@ -1,12 +1,12 @@
 import {
   VerifySchema
-} from "../chunk-KNFHXSE5.js";
-import "../chunk-WL5BF26E.js";
+} from "../chunk-BTKJKLCB.js";
+import "../chunk-2LCTKBU3.js";
 import "../chunk-A4BSWX5D.js";
-import "../chunk-2UUZOEA7.js";
-import "../chunk-VYSP73KB.js";
-import "../chunk-PUON7HP5.js";
-import "../chunk-3AACKVGA.js";
+import "../chunk-RILSVR74.js";
+import "../chunk-J6HLIC77.js";
+import "../chunk-FUUGVGYY.js";
+import "../chunk-65EVYD2Y.js";
 import "../chunk-W33MLXYW.js";
 import "../chunk-34NLRFFT.js";
 import "../chunk-LFCNPXLH.js";