atmn 1.1.25 → 2.0.0

package/dist/index.js

@@ -0,0 +1,2906 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/generated/features.ts
+var feature = (input) => input;
+// src/generated/licenses.ts
+var license = (input) => input;
+// src/generated/plans.ts
+var plan = (input) => input;
+// src/generated/referralPrograms.ts
+var referralProgram = (input) => input;
+// src/generated/rewards.ts
+var coupon = (input) => ({ coupon: input });
+var featureGrant = (input) => ({
+  featureGrant: input
+});
+// src/generated/variants.ts
+var variant = (input) => input;
+// src/generated/lintRules.ts
+var LINT_RULES = {
+  features: {
+    label: "feature",
+    idField: "featureId",
+    required: ["featureId", "name", "type"],
+    fields: {
+      type: {
+        enum: ["boolean", "metered", "credit_system", "ai_credit_system"]
+      },
+      defaultMarkup: {
+        minimum: -100
+      },
+      internalId: {
+        minLength: 1
+      }
+    },
+    rules: [
+      {
+        kind: "requiredWhen",
+        when: "type",
+        equals: "metered",
+        require: ["consumable"],
+        because: "Omitting it silently creates a non-consumable feature, which never resets."
+      },
+      {
+        kind: "unique",
+        field: "featureId",
+        because: "Two features claiming one id race to define the same row."
+      },
+      {
+        kind: "unique",
+        field: "internalId",
+        because: "A stable id names exactly one row; two fixtures cannot both be it."
+      }
+    ]
+  },
+  "features.creditSchema": {
+    variants: {
+      on: "tierBehavior",
+      byValue: {
+        graduated: {
+          required: ["meteredFeatureId", "tierBehavior", "tiers"],
+          fields: {
+            meteredFeatureId: {
+              minLength: 1
+            },
+            billingUnits: {
+              exclusiveMinimum: 0
+            },
+            tierBehavior: {
+              enum: ["graduated"]
+            },
+            tiers: {
+              minItems: 1
+            }
+          }
+        }
+      },
+      fallback: {
+        required: ["creditCost", "meteredFeatureId"],
+        fields: {
+          meteredFeatureId: {
+            minLength: 1
+          },
+          billingUnits: {
+            exclusiveMinimum: 0
+          },
+          creditCost: {
+            minimum: 0
+          }
+        }
+      }
+    }
+  },
+  "features.creditSchema.dimensions": {
+    keys: {
+      minLength: 1,
+      maxLength: 64
+    }
+  },
+  "features.creditSchema.dimensions.*": {
+    variants: {
+      on: "tierBehavior",
+      byValue: {
+        graduated: {
+          required: ["match", "tierBehavior", "tiers"],
+          fields: {
+            priority: {
+              minimum: -9007199254740991,
+              maximum: 9007199254740991
+            },
+            tierBehavior: {
+              enum: ["graduated"]
+            },
+            tiers: {
+              minItems: 1
+            }
+          }
+        }
+      },
+      fallback: {
+        required: ["creditCost", "match"],
+        fields: {
+          priority: {
+            minimum: -9007199254740991,
+            maximum: 9007199254740991
+          },
+          creditCost: {
+            minimum: 0
+          }
+        }
+      }
+    }
+  },
+  "features.creditSchema.dimensions.*.tiers": {
+    required: ["creditCost", "to"],
+    fields: {
+      to: {
+        exclusiveMinimum: 0
+      },
+      creditCost: {
+        minimum: 0
+      }
+    }
+  },
+  "features.creditSchema.multipliers": {
+    keys: {
+      minLength: 1,
+      maxLength: 64
+    }
+  },
+  "features.creditSchema.multipliers.*": {
+    required: ["match"],
+    fields: {
+      factor: {
+        exclusiveMinimum: 0
+      }
+    }
+  },
+  "features.creditSchema.tiers": {
+    required: ["creditCost", "to"],
+    fields: {
+      to: {
+        exclusiveMinimum: 0
+      },
+      creditCost: {
+        minimum: 0
+      }
+    }
+  },
+  "features.display": {
+    required: ["plural", "singular"]
+  },
+  "features.modelMarkups": {
+    keys: {
+      pattern: ".+\\/.+"
+    }
+  },
+  "features.modelMarkups.*": {
+    fields: {
+      markup: {
+        minimum: -100
+      },
+      inputCost: {
+        minimum: 0
+      },
+      outputCost: {
+        minimum: 0
+      }
+    }
+  },
+  "features.providerMarkups.*": {
+    required: ["markup"],
+    fields: {
+      markup: {
+        minimum: -100
+      }
+    }
+  },
+  plans: {
+    label: "plan",
+    idField: "planId",
+    required: ["planId", "versionSlug"],
+    fields: {
+      planId: {
+        minLength: 1,
+        pattern: "^[a-zA-Z0-9_-]+$"
+      },
+      newPlanId: {
+        minLength: 1,
+        pattern: "^[a-zA-Z0-9_-]+$"
+      },
+      internalId: {
+        minLength: 1
+      },
+      name: {
+        minLength: 1
+      },
+      version: {
+        minimum: 1,
+        maximum: 9007199254740991
+      },
+      versionSlug: {
+        minLength: 1,
+        pattern: "^[a-zA-Z0-9_-]+$"
+      },
+      newVersionSlug: {
+        minLength: 1,
+        pattern: "^[a-zA-Z0-9_-]+$"
+      },
+      versioning: {
+        enum: ["existing", "new_version", "all_versions"]
+      },
+      baseVariantId: {
+        minLength: 1,
+        pattern: "^[a-zA-Z0-9_-]+$"
+      }
+    },
+    rules: [
+      {
+        kind: "unique",
+        field: "internalId",
+        because: "A stable id names exactly one row; two fixtures cannot both be it."
+      },
+      {
+        kind: "unique",
+        field: "planId",
+        alongside: "versionSlug",
+        because: "A plan id plus a version slug names exactly one version."
+      },
+      {
+        kind: "linkedOnce",
+        groupBy: "planId",
+        namedBy: "versionSlug",
+        absentMeans: "v1",
+        collection: "variants",
+        identity: "variantPlanId",
+        pins: ["versionSlug", "version"],
+        because: "When versioning a base plan with variants linked, you also need to version the variant, and relink the new version to the new variant version."
+      },
+      {
+        kind: "exactlyOneActive",
+        groupBy: "planId",
+        field: "active",
+        label: "Plan",
+        because: "Every version of a plan lives in plans; mark the one customers can buy active: true and the rest active: false."
+      }
+    ]
+  },
+  "plans.billingControls.autoTopups": {
+    required: ["featureId", "quantity", "threshold"],
+    fields: {
+      quantity: {
+        minimum: 1
+      }
+    }
+  },
+  "plans.billingControls.autoTopups.purchaseLimit": {
+    required: ["interval", "limit"],
+    fields: {
+      interval: {
+        enum: ["hour", "day", "week", "month"]
+      },
+      intervalCount: {
+        minimum: 1
+      },
+      limit: {
+        minimum: 1
+      },
+      count: {
+        minimum: 0
+      }
+    }
+  },
+  "plans.billingControls.overageAllowed": {
+    required: ["featureId"]
+  },
+  "plans.billingControls.spendLimits": {
+    fields: {
+      limitType: {
+        enum: ["absolute", "usage_percentage"]
+      },
+      overageLimit: {
+        minimum: 0
+      }
+    }
+  },
+  "plans.billingControls.usageAlerts": {
+    required: ["threshold", "thresholdType"],
+    fields: {
+      threshold: {
+        minimum: 0
+      },
+      thresholdType: {
+        enum: [
+          "usage",
+          "usage_percentage",
+          "remaining",
+          "remaining_percentage"
+        ]
+      },
+      basis: {
+        enum: ["balance", "included", "recurring", "usage_limit"]
+      }
+    }
+  },
+  "plans.billingControls.usageAlerts.filter": {
+    required: ["properties"]
+  },
+  "plans.billingControls.usageAlerts.filter.properties": {
+    keys: {
+      minLength: 1,
+      maxLength: 64
+    }
+  },
+  "plans.billingControls.usageLimits": {
+    required: ["featureId", "interval", "limit"],
+    fields: {
+      limit: {
+        minimum: 0
+      },
+      interval: {
+        enum: ["day", "week", "month", "year"]
+      },
+      anchor: {
+        enum: ["billing_cycle", "utc"]
+      }
+    }
+  },
+  "plans.billingControls.usageLimits.filter": {
+    required: ["properties"]
+  },
+  "plans.billingControls.usageLimits.filter.properties": {
+    keys: {
+      minLength: 1,
+      maxLength: 64
+    }
+  },
+  "plans.freeTrial": {
+    required: ["durationLength"],
+    fields: {
+      durationType: {
+        enum: ["day", "month", "year"]
+      },
+      onEnd: {
+        enum: ["bill", "revert"]
+      }
+    }
+  },
+  "plans.items": {
+    label: "item",
+    idField: "featureId",
+    required: ["featureId"],
+    fields: {
+      included: {
+        maximum: 10000000000000
+      }
+    },
+    rules: [
+      {
+        kind: "exists",
+        field: "featureId",
+        in: "features",
+        matching: "featureId",
+        because: "A plan item meters a feature this config does not declare."
+      },
+      {
+        kind: "targetHas",
+        when: "featureOverride",
+        field: "featureId",
+        in: "features",
+        matching: "featureId",
+        target: "type",
+        equals: "credit_system",
+        because: "featureOverride is only honoured on classic credit-system features."
+      },
+      {
+        kind: "targetLacks",
+        field: "featureId",
+        in: "features",
+        matching: "featureId",
+        target: "archived",
+        label: "Feature",
+        parentGuard: "archived",
+        parentIdField: "planId",
+        parentLabel: "plan",
+        because: "An archived feature should not gain new customers through a live plan."
+      }
+    ]
+  },
+  "plans.items.featureOverride.creditSchema": {
+    variants: {
+      on: "tierBehavior",
+      byValue: {
+        graduated: {
+          required: ["meteredFeatureId", "tierBehavior", "tiers"],
+          fields: {
+            meteredFeatureId: {
+              minLength: 1
+            },
+            billingUnits: {
+              exclusiveMinimum: 0
+            },
+            tierBehavior: {
+              enum: ["graduated"]
+            },
+            tiers: {
+              minItems: 1
+            }
+          }
+        }
+      },
+      fallback: {
+        required: ["creditCost", "meteredFeatureId"],
+        fields: {
+          meteredFeatureId: {
+            minLength: 1
+          },
+          billingUnits: {
+            exclusiveMinimum: 0
+          },
+          creditCost: {
+            minimum: 0
+          }
+        }
+      }
+    }
+  },
+  "plans.items.featureOverride.creditSchema.dimensions": {
+    keys: {
+      minLength: 1,
+      maxLength: 64
+    }
+  },
+  "plans.items.featureOverride.creditSchema.dimensions.*": {
+    variants: {
+      on: "tierBehavior",
+      byValue: {
+        graduated: {
+          required: ["match", "tierBehavior", "tiers"],
+          fields: {
+            priority: {
+              minimum: -9007199254740991,
+              maximum: 9007199254740991
+            },
+            tierBehavior: {
+              enum: ["graduated"]
+            },
+            tiers: {
+              minItems: 1
+            }
+          }
+        }
+      },
+      fallback: {
+        required: ["creditCost", "match"],
+        fields: {
+          priority: {
+            minimum: -9007199254740991,
+            maximum: 9007199254740991
+          },
+          creditCost: {
+            minimum: 0
+          }
+        }
+      }
+    }
+  },
+  "plans.items.featureOverride.creditSchema.dimensions.*.tiers": {
+    required: ["creditCost", "to"],
+    fields: {
+      to: {
+        exclusiveMinimum: 0
+      },
+      creditCost: {
+        minimum: 0
+      }
+    }
+  },
+  "plans.items.featureOverride.creditSchema.multipliers": {
+    keys: {
+      minLength: 1,
+      maxLength: 64
+    }
+  },
+  "plans.items.featureOverride.creditSchema.multipliers.*": {
+    required: ["match"],
+    fields: {
+      factor: {
+        exclusiveMinimum: 0
+      }
+    }
+  },
+  "plans.items.featureOverride.creditSchema.tiers": {
+    required: ["creditCost", "to"],
+    fields: {
+      to: {
+        exclusiveMinimum: 0
+      },
+      creditCost: {
+        minimum: 0
+      }
+    }
+  },
+  "plans.items.featureOverride.markups": {
+    fields: {
+      defaultMarkup: {
+        minimum: -100
+      }
+    }
+  },
+  "plans.items.featureOverride.markups.modelMarkups": {
+    keys: {
+      pattern: ".+\\/.+"
+    }
+  },
+  "plans.items.featureOverride.markups.modelMarkups.*": {
+    fields: {
+      markup: {
+        minimum: -100
+      },
+      inputCost: {
+        minimum: 0
+      },
+      outputCost: {
+        minimum: 0
+      }
+    }
+  },
+  "plans.items.featureOverride.markups.providerMarkups.*": {
+    required: ["markup"],
+    fields: {
+      markup: {
+        minimum: -100
+      }
+    }
+  },
+  "plans.items.price": {
+    label: "price",
+    required: ["billingMethod", "interval"],
+    fields: {
+      tierBehavior: {
+        enum: ["graduated", "volume"]
+      },
+      interval: {
+        enum: ["one_off", "week", "month", "quarter", "semi_annual", "year"]
+      },
+      billingMethod: {
+        enum: ["prepaid", "usage_based"]
+      },
+      allocatedBilling: {
+        enum: ["arrear", "prorated_legacy"]
+      }
+    },
+    rules: [
+      {
+        kind: "valueWhen",
+        when: "tierBehavior",
+        equals: "volume",
+        field: "billingMethod",
+        mustBe: "prepaid",
+        because: "Volume tiers are prepaid-only."
+      }
+    ]
+  },
+  "plans.items.price.additionalCurrencies": {
+    required: ["amount", "currency"]
+  },
+  "plans.items.price.processors.stripe": {
+    required: ["priceId"]
+  },
+  "plans.items.price.tiers": {
+    required: ["to"]
+  },
+  "plans.items.price.tiers.additionalCurrencies": {
+    required: ["currency"]
+  },
+  "plans.items.proration": {
+    required: ["onDecrease", "onIncrease"],
+    fields: {
+      onIncrease: {
+        enum: [
+          "bill_immediately",
+          "prorate_immediately",
+          "prorate_next_cycle",
+          "bill_next_cycle"
+        ]
+      },
+      onDecrease: {
+        enum: [
+          "prorate",
+          "prorate_immediately",
+          "prorate_next_cycle",
+          "none",
+          "no_prorations"
+        ]
+      }
+    }
+  },
+  "plans.items.reset": {
+    required: ["interval"],
+    fields: {
+      interval: {
+        enum: [
+          "one_off",
+          "minute",
+          "hour",
+          "day",
+          "week",
+          "month",
+          "quarter",
+          "semi_annual",
+          "year"
+        ]
+      }
+    }
+  },
+  "plans.items.rollover": {
+    required: ["expiryDurationType"],
+    fields: {
+      expiryDurationType: {
+        enum: ["month", "forever"]
+      }
+    }
+  },
+  "plans.items.thresholdBilling": {
+    required: ["threshold"],
+    fields: {
+      threshold: {
+        exclusiveMinimum: 0
+      }
+    }
+  },
+  "plans.licenses": {
+    label: "license",
+    idField: "licensePlanId",
+    required: ["licensePlanId", "versionSlug"],
+    fields: {
+      included: {
+        minimum: 0,
+        maximum: 9007199254740991
+      }
+    }
+  },
+  "plans.licenses.customize.addItems": {
+    required: ["featureId"],
+    fields: {
+      included: {
+        maximum: 10000000000000
+      }
+    }
+  },
+  "plans.licenses.customize.addItems.featureOverride.creditSchema": {
+    variants: {
+      on: "tierBehavior",
+      byValue: {
+        graduated: {
+          required: ["meteredFeatureId", "tierBehavior", "tiers"],
+          fields: {
+            meteredFeatureId: {
+              minLength: 1
+            },
+            billingUnits: {
+              exclusiveMinimum: 0
+            },
+            tierBehavior: {
+              enum: ["graduated"]
+            },
+            tiers: {
+              minItems: 1
+            }
+          }
+        }
+      },
+      fallback: {
+        required: ["creditCost", "meteredFeatureId"],
+        fields: {
+          meteredFeatureId: {
+            minLength: 1
+          },
+          billingUnits: {
+            exclusiveMinimum: 0
+          },
+          creditCost: {
+            minimum: 0
+          }
+        }
+      }
+    }
+  },
+  "plans.licenses.customize.addItems.featureOverride.creditSchema.dimensions": {
+    keys: {
+      minLength: 1,
+      maxLength: 64
+    }
+  },
+  "plans.licenses.customize.addItems.featureOverride.creditSchema.dimensions.*": {
+    variants: {
+      on: "tierBehavior",
+      byValue: {
+        graduated: {
+          required: ["match", "tierBehavior", "tiers"],
+          fields: {
+            priority: {
+              minimum: -9007199254740991,
+              maximum: 9007199254740991
+            },
+            tierBehavior: {
+              enum: ["graduated"]
+            },
+            tiers: {
+              minItems: 1
+            }
+          }
+        }
+      },
+      fallback: {
+        required: ["creditCost", "match"],
+        fields: {
+          priority: {
+            minimum: -9007199254740991,
+            maximum: 9007199254740991
+          },
+          creditCost: {
+            minimum: 0
+          }
+        }
+      }
+    }
+  },
+  "plans.licenses.customize.addItems.featureOverride.creditSchema.dimensions.*.tiers": {
+    required: ["creditCost", "to"],
+    fields: {
+      to: {
+        exclusiveMinimum: 0
+      },
+      creditCost: {
+        minimum: 0
+      }
+    }
+  },
+  "plans.licenses.customize.addItems.featureOverride.creditSchema.multipliers": {
+    keys: {
+      minLength: 1,
+      maxLength: 64
+    }
+  },
+  "plans.licenses.customize.addItems.featureOverride.creditSchema.multipliers.*": {
+    required: ["match"],
+    fields: {
+      factor: {
+        exclusiveMinimum: 0
+      }
+    }
+  },
+  "plans.licenses.customize.addItems.featureOverride.creditSchema.tiers": {
+    required: ["creditCost", "to"],
+    fields: {
+      to: {
+        exclusiveMinimum: 0
+      },
+      creditCost: {
+        minimum: 0
+      }
+    }
+  },
+  "plans.licenses.customize.addItems.featureOverride.markups": {
+    fields: {
+      defaultMarkup: {
+        minimum: -100
+      }
+    }
+  },
+  "plans.licenses.customize.addItems.featureOverride.markups.modelMarkups": {
+    keys: {
+      pattern: ".+\\/.+"
+    }
+  },
+  "plans.licenses.customize.addItems.featureOverride.markups.modelMarkups.*": {
+    fields: {
+      markup: {
+        minimum: -100
+      },
+      inputCost: {
+        minimum: 0
+      },
+      outputCost: {
+        minimum: 0
+      }
+    }
+  },
+  "plans.licenses.customize.addItems.featureOverride.markups.providerMarkups.*": {
+    required: ["markup"],
+    fields: {
+      markup: {
+        minimum: -100
+      }
+    }
+  },
+  "plans.licenses.customize.addItems.price": {
+    required: ["billingMethod", "interval"],
+    fields: {
+      tierBehavior: {
+        enum: ["graduated", "volume"]
+      },
+      interval: {
+        enum: ["one_off", "week", "month", "quarter", "semi_annual", "year"]
+      },
+      billingMethod: {
+        enum: ["prepaid", "usage_based"]
+      },
+      allocatedBilling: {
+        enum: ["arrear", "prorated_legacy"]
+      }
+    }
+  },
+  "plans.licenses.customize.addItems.price.additionalCurrencies": {
+    required: ["amount", "currency"]
+  },
+  "plans.licenses.customize.addItems.price.tiers": {
+    required: ["to"]
+  },
+  "plans.licenses.customize.addItems.price.tiers.additionalCurrencies": {
+    required: ["currency"]
+  },
+  "plans.licenses.customize.addItems.proration": {
+    required: ["onDecrease", "onIncrease"],
+    fields: {
+      onIncrease: {
+        enum: [
+          "bill_immediately",
+          "prorate_immediately",
+          "prorate_next_cycle",
+          "bill_next_cycle"
+        ]
+      },
+      onDecrease: {
+        enum: [
+          "prorate",
+          "prorate_immediately",
+          "prorate_next_cycle",
+          "none",
+          "no_prorations"
+        ]
+      }
+    }
+  },
+  "plans.licenses.customize.addItems.reset": {
+    required: ["interval"],
+    fields: {
+      interval: {
+        enum: [
+          "one_off",
+          "minute",
+          "hour",
+          "day",
+          "week",
+          "month",
+          "quarter",
+          "semi_annual",
+          "year"
+        ]
+      }
+    }
+  },
+  "plans.licenses.customize.addItems.rollover": {
+    required: ["expiryDurationType"],
+    fields: {
+      expiryDurationType: {
+        enum: ["month", "forever"]
+      }
+    }
+  },
+  "plans.licenses.customize.addItems.thresholdBilling": {
+    required: ["threshold"],
+    fields: {
+      threshold: {
+        exclusiveMinimum: 0
+      }
+    }
+  },
+  "plans.licenses.customize.price": {
+    required: ["amount", "interval"],
+    fields: {
+      interval: {
+        enum: ["one_off", "week", "month", "quarter", "semi_annual", "year"]
+      }
+    }
+  },
+  "plans.licenses.customize.price.additionalCurrencies": {
+    required: ["amount", "currency"]
+  },
+  "plans.licenses.customize.removeItems": {
+    fields: {
+      billingMethod: {
+        enum: ["prepaid", "usage_based"]
+      },
+      interval: {
+        enum: [
+          "one_off",
+          "week",
+          "month",
+          "quarter",
+          "semi_annual",
+          "year",
+          "minute",
+          "hour",
+          "day"
+        ]
+      },
+      intervalCount: {
+        minimum: -9007199254740991,
+        maximum: 9007199254740991,
+        exclusiveMinimum: 0
+      },
+      included: {
+        maximum: 10000000000000
+      }
+    }
+  },
+  "plans.price": {
+    required: ["amount", "interval"],
+    fields: {
+      interval: {
+        enum: ["one_off", "week", "month", "quarter", "semi_annual", "year"]
+      }
+    }
+  },
+  "plans.price.additionalCurrencies": {
+    required: ["amount", "currency"]
+  },
+  "plans.price.processors.stripe": {
+    required: ["priceId"]
+  },
+  "plans.processors.revenuecat": {
+    required: ["products"]
+  },
+  "plans.processors.revenuecat.products": {
+    required: ["productId"]
+  },
+  "plans.processors.revenuecat.products.featureQuantities": {
+    required: ["featureId"],
+    fields: {
+      quantity: {
+        minimum: 0
+      }
+    }
+  },
+  "plans.processors.stripe": {
+    required: ["productId"]
+  },
+  "plans.propagate.licenseParents": {
+    required: ["planId"],
+    fields: {
+      planId: {
+        minLength: 1,
+        pattern: "^[a-zA-Z0-9_-]+$"
+      },
+      version: {
+        minimum: 1,
+        maximum: 9007199254740991
+      },
+      versionSlug: {
+        minLength: 1,
+        pattern: "^[a-zA-Z0-9_-]+$"
+      },
+      newVersionSlug: {
+        minLength: 1,
+        pattern: "^[a-zA-Z0-9_-]+$"
+      }
+    }
+  },
+  "plans.propagate.variants": {
+    required: ["planId"],
+    fields: {
+      planId: {
+        minLength: 1,
+        pattern: "^[a-zA-Z0-9_-]+$"
+      },
+      version: {
+        minimum: 1,
+        maximum: 9007199254740991
+      },
+      versionSlug: {
+        minLength: 1,
+        pattern: "^[a-zA-Z0-9_-]+$"
+      },
+      newVersionSlug: {
+        minLength: 1,
+        pattern: "^[a-zA-Z0-9_-]+$"
+      }
+    }
+  },
+  "plans.variants": {
+    label: "variant",
+    idField: "variantPlanId",
+    required: ["variantPlanId", "versionSlug"],
+    fields: {
+      variantPlanId: {
+        minLength: 1,
+        pattern: "^[a-zA-Z0-9_-]+$"
+      },
+      internalId: {
+        minLength: 1
+      },
+      version: {
+        minimum: 1,
+        maximum: 9007199254740991
+      },
+      versionSlug: {
+        minLength: 1,
+        pattern: "^[a-zA-Z0-9_-]+$"
+      },
+      name: {
+        minLength: 1
+      },
+      newPlanId: {
+        minLength: 1,
+        pattern: "^[a-zA-Z0-9_-]+$"
+      },
+      newVersionSlug: {
+        minLength: 1,
+        pattern: "^[a-zA-Z0-9_-]+$"
+      },
+      baseVariantId: {
+        minLength: 1,
+        pattern: "^[a-zA-Z0-9_-]+$"
+      }
+    }
+  },
+  "plans.variants.customize.addItems": {
+    required: ["featureId"],
+    fields: {
+      included: {
+        maximum: 10000000000000
+      }
+    }
+  },
+  "plans.variants.customize.addItems.featureOverride.creditSchema": {
+    variants: {
+      on: "tierBehavior",
+      byValue: {
+        graduated: {
+          required: ["meteredFeatureId", "tierBehavior", "tiers"],
+          fields: {
+            meteredFeatureId: {
+              minLength: 1
+            },
+            billingUnits: {
+              exclusiveMinimum: 0
+            },
+            tierBehavior: {
+              enum: ["graduated"]
+            },
+            tiers: {
+              minItems: 1
+            }
+          }
+        }
+      },
+      fallback: {
+        required: ["creditCost", "meteredFeatureId"],
+        fields: {
+          meteredFeatureId: {
+            minLength: 1
+          },
+          billingUnits: {
+            exclusiveMinimum: 0
+          },
+          creditCost: {
+            minimum: 0
+          }
+        }
+      }
+    }
+  },
+  "plans.variants.customize.addItems.featureOverride.creditSchema.dimensions": {
+    keys: {
+      minLength: 1,
+      maxLength: 64
+    }
+  },
+  "plans.variants.customize.addItems.featureOverride.creditSchema.dimensions.*": {
+    variants: {
+      on: "tierBehavior",
+      byValue: {
+        graduated: {
+          required: ["match", "tierBehavior", "tiers"],
+          fields: {
+            priority: {
+              minimum: -9007199254740991,
+              maximum: 9007199254740991
+            },
+            tierBehavior: {
+              enum: ["graduated"]
+            },
+            tiers: {
+              minItems: 1
+            }
+          }
+        }
+      },
+      fallback: {
+        required: ["creditCost", "match"],
+        fields: {
+          priority: {
+            minimum: -9007199254740991,
+            maximum: 9007199254740991
+          },
+          creditCost: {
+            minimum: 0
+          }
+        }
+      }
+    }
+  },
+  "plans.variants.customize.addItems.featureOverride.creditSchema.dimensions.*.tiers": {
+    required: ["creditCost", "to"],
+    fields: {
+      to: {
+        exclusiveMinimum: 0
+      },
+      creditCost: {
+        minimum: 0
+      }
+    }
+  },
+  "plans.variants.customize.addItems.featureOverride.creditSchema.multipliers": {
+    keys: {
+      minLength: 1,
+      maxLength: 64
+    }
+  },
+  "plans.variants.customize.addItems.featureOverride.creditSchema.multipliers.*": {
+    required: ["match"],
+    fields: {
+      factor: {
+        exclusiveMinimum: 0
+      }
+    }
+  },
+  "plans.variants.customize.addItems.featureOverride.creditSchema.tiers": {
+    required: ["creditCost", "to"],
+    fields: {
+      to: {
+        exclusiveMinimum: 0
+      },
+      creditCost: {
+        minimum: 0
+      }
+    }
+  },
+  "plans.variants.customize.addItems.featureOverride.markups": {
+    fields: {
+      defaultMarkup: {
+        minimum: -100
+      }
+    }
+  },
+  "plans.variants.customize.addItems.featureOverride.markups.modelMarkups": {
+    keys: {
+      pattern: ".+\\/.+"
+    }
+  },
+  "plans.variants.customize.addItems.featureOverride.markups.modelMarkups.*": {
+    fields: {
+      markup: {
+        minimum: -100
+      },
+      inputCost: {
+        minimum: 0
+      },
+      outputCost: {
+        minimum: 0
+      }
+    }
+  },
+  "plans.variants.customize.addItems.featureOverride.markups.providerMarkups.*": {
+    required: ["markup"],
+    fields: {
+      markup: {
+        minimum: -100
+      }
+    }
+  },
+  "plans.variants.customize.addItems.price": {
+    required: ["billingMethod", "interval"],
+    fields: {
+      tierBehavior: {
+        enum: ["graduated", "volume"]
+      },
+      interval: {
+        enum: ["one_off", "week", "month", "quarter", "semi_annual", "year"]
+      },
+      billingMethod: {
+        enum: ["prepaid", "usage_based"]
+      },
+      allocatedBilling: {
+        enum: ["arrear", "prorated_legacy"]
+      }
+    }
+  },
+  "plans.variants.customize.addItems.price.additionalCurrencies": {
+    required: ["amount", "currency"]
+  },
+  "plans.variants.customize.addItems.price.tiers": {
+    required: ["to"]
+  },
+  "plans.variants.customize.addItems.price.tiers.additionalCurrencies": {
+    required: ["currency"]
+  },
+  "plans.variants.customize.addItems.proration": {
+    required: ["onDecrease", "onIncrease"],
+    fields: {
+      onIncrease: {
+        enum: [
+          "bill_immediately",
+          "prorate_immediately",
+          "prorate_next_cycle",
+          "bill_next_cycle"
+        ]
+      },
+      onDecrease: {
+        enum: [
+          "prorate",
+          "prorate_immediately",
+          "prorate_next_cycle",
+          "none",
+          "no_prorations"
+        ]
+      }
+    }
+  },
+  "plans.variants.customize.addItems.reset": {
+    required: ["interval"],
+    fields: {
+      interval: {
+        enum: [
+          "one_off",
+          "minute",
+          "hour",
+          "day",
+          "week",
+          "month",
+          "quarter",
+          "semi_annual",
+          "year"
+        ]
+      }
+    }
+  },
+  "plans.variants.customize.addItems.rollover": {
+    required: ["expiryDurationType"],
+    fields: {
+      expiryDurationType: {
+        enum: ["month", "forever"]
+      }
+    }
+  },
+  "plans.variants.customize.addItems.thresholdBilling": {
+    required: ["threshold"],
+    fields: {
+      threshold: {
+        exclusiveMinimum: 0
+      }
+    }
+  },
+  "plans.variants.customize.billingControls.autoTopups": {
+    required: ["featureId", "quantity", "threshold"],
+    fields: {
+      quantity: {
+        minimum: 1
+      }
+    }
+  },
+  "plans.variants.customize.billingControls.autoTopups.purchaseLimit": {
+    required: ["interval", "limit"],
+    fields: {
+      interval: {
+        enum: ["hour", "day", "week", "month"]
+      },
+      intervalCount: {
+        minimum: 1
+      },
+      limit: {
+        minimum: 1
+      },
+      count: {
+        minimum: 0
+      }
+    }
+  },
+  "plans.variants.customize.billingControls.overageAllowed": {
+    required: ["featureId"]
+  },
+  "plans.variants.customize.billingControls.spendLimits": {
+    fields: {
+      limitType: {
+        enum: ["absolute", "usage_percentage"]
+      },
+      overageLimit: {
+        minimum: 0
+      }
+    }
+  },
+  "plans.variants.customize.billingControls.usageAlerts": {
+    required: ["threshold", "thresholdType"],
+    fields: {
+      threshold: {
+        minimum: 0
+      },
+      thresholdType: {
+        enum: [
+          "usage",
+          "usage_percentage",
+          "remaining",
+          "remaining_percentage"
+        ]
+      },
+      basis: {
+        enum: ["balance", "included", "recurring", "usage_limit"]
+      }
+    }
+  },
+  "plans.variants.customize.billingControls.usageAlerts.filter": {
+    required: ["properties"]
+  },
+  "plans.variants.customize.billingControls.usageAlerts.filter.properties": {
+    keys: {
+      minLength: 1,
+      maxLength: 64
+    }
+  },
+  "plans.variants.customize.billingControls.usageLimits": {
+    required: ["featureId", "interval", "limit"],
+    fields: {
+      limit: {
+        minimum: 0
+      },
+      interval: {
+        enum: ["day", "week", "month", "year"]
+      },
+      anchor: {
+        enum: ["billing_cycle", "utc"]
+      }
+    }
+  },
+  "plans.variants.customize.billingControls.usageLimits.filter": {
+    required: ["properties"]
+  },
+  "plans.variants.customize.billingControls.usageLimits.filter.properties": {
+    keys: {
+      minLength: 1,
+      maxLength: 64
+    }
+  },
+  "plans.variants.customize.freeTrial": {
+    required: ["durationLength"],
+    fields: {
+      durationType: {
+        enum: ["day", "month", "year"]
+      },
+      onEnd: {
+        enum: ["bill", "revert"]
+      }
+    }
+  },
+  "plans.variants.customize.items": {
+    required: ["featureId"],
+    fields: {
+      included: {
+        maximum: 10000000000000
+      }
+    }
+  },
+  "plans.variants.customize.items.featureOverride.creditSchema": {
+    variants: {
+      on: "tierBehavior",
+      byValue: {
+        graduated: {
+          required: ["meteredFeatureId", "tierBehavior", "tiers"],
+          fields: {
+            meteredFeatureId: {
+              minLength: 1
+            },
+            billingUnits: {
+              exclusiveMinimum: 0
+            },
+            tierBehavior: {
+              enum: ["graduated"]
+            },
+            tiers: {
+              minItems: 1
+            }
+          }
+        }
+      },
+      fallback: {
+        required: ["creditCost", "meteredFeatureId"],
+        fields: {
+          meteredFeatureId: {
+            minLength: 1
+          },
+          billingUnits: {
+            exclusiveMinimum: 0
+          },
+          creditCost: {
+            minimum: 0
+          }
+        }
+      }
+    }
+  },
+  "plans.variants.customize.items.featureOverride.creditSchema.dimensions": {
+    keys: {
+      minLength: 1,
+      maxLength: 64
+    }
+  },
+  "plans.variants.customize.items.featureOverride.creditSchema.dimensions.*": {
+    variants: {
+      on: "tierBehavior",
+      byValue: {
+        graduated: {
+          required: ["match", "tierBehavior", "tiers"],
+          fields: {
+            priority: {
+              minimum: -9007199254740991,
+              maximum: 9007199254740991
+            },
+            tierBehavior: {
+              enum: ["graduated"]
+            },
+            tiers: {
+              minItems: 1
+            }
+          }
+        }
+      },
+      fallback: {
+        required: ["creditCost", "match"],
+        fields: {
+          priority: {
+            minimum: -9007199254740991,
+            maximum: 9007199254740991
+          },
+          creditCost: {
+            minimum: 0
+          }
+        }
+      }
+    }
+  },
+  "plans.variants.customize.items.featureOverride.creditSchema.dimensions.*.tiers": {
+    required: ["creditCost", "to"],
+    fields: {
+      to: {
+        exclusiveMinimum: 0
+      },
+      creditCost: {
+        minimum: 0
+      }
+    }
+  },
+  "plans.variants.customize.items.featureOverride.creditSchema.multipliers": {
+    keys: {
+      minLength: 1,
+      maxLength: 64
+    }
+  },
+  "plans.variants.customize.items.featureOverride.creditSchema.multipliers.*": {
+    required: ["match"],
+    fields: {
+      factor: {
+        exclusiveMinimum: 0
+      }
+    }
+  },
+  "plans.variants.customize.items.featureOverride.creditSchema.tiers": {
+    required: ["creditCost", "to"],
+    fields: {
+      to: {
+        exclusiveMinimum: 0
+      },
+      creditCost: {
+        minimum: 0
+      }
+    }
+  },
+  "plans.variants.customize.items.featureOverride.markups": {
+    fields: {
+      defaultMarkup: {
+        minimum: -100
+      }
+    }
+  },
+  "plans.variants.customize.items.featureOverride.markups.modelMarkups": {
+    keys: {
+      pattern: ".+\\/.+"
+    }
+  },
+  "plans.variants.customize.items.featureOverride.markups.modelMarkups.*": {
+    fields: {
+      markup: {
+        minimum: -100
+      },
+      inputCost: {
+        minimum: 0
+      },
+      outputCost: {
+        minimum: 0
+      }
+    }
+  },
+  "plans.variants.customize.items.featureOverride.markups.providerMarkups.*": {
+    required: ["markup"],
+    fields: {
+      markup: {
+        minimum: -100
+      }
+    }
+  },
+  "plans.variants.customize.items.price": {
+    required: ["billingMethod", "interval"],
+    fields: {
+      tierBehavior: {
+        enum: ["graduated", "volume"]
+      },
+      interval: {
+        enum: ["one_off", "week", "month", "quarter", "semi_annual", "year"]
+      },
+      billingMethod: {
+        enum: ["prepaid", "usage_based"]
+      },
+      allocatedBilling: {
+        enum: ["arrear", "prorated_legacy"]
+      }
+    }
+  },
+  "plans.variants.customize.items.price.additionalCurrencies": {
+    required: ["amount", "currency"]
+  },
+  "plans.variants.customize.items.price.tiers": {
+    required: ["to"]
+  },
+  "plans.variants.customize.items.price.tiers.additionalCurrencies": {
+    required: ["currency"]
+  },
+  "plans.variants.customize.items.proration": {
+    required: ["onDecrease", "onIncrease"],
+    fields: {
+      onIncrease: {
+        enum: [
+          "bill_immediately",
+          "prorate_immediately",
+          "prorate_next_cycle",
+          "bill_next_cycle"
+        ]
+      },
+      onDecrease: {
+        enum: [
+          "prorate",
+          "prorate_immediately",
+          "prorate_next_cycle",
+          "none",
+          "no_prorations"
+        ]
+      }
+    }
+  },
+  "plans.variants.customize.items.reset": {
+    required: ["interval"],
+    fields: {
+      interval: {
+        enum: [
+          "one_off",
+          "minute",
+          "hour",
+          "day",
+          "week",
+          "month",
+          "quarter",
+          "semi_annual",
+          "year"
+        ]
+      }
+    }
+  },
+  "plans.variants.customize.items.rollover": {
+    required: ["expiryDurationType"],
+    fields: {
+      expiryDurationType: {
+        enum: ["month", "forever"]
+      }
+    }
+  },
+  "plans.variants.customize.items.thresholdBilling": {
+    required: ["threshold"],
+    fields: {
+      threshold: {
+        exclusiveMinimum: 0
+      }
+    }
+  },
+  "plans.variants.customize.price": {
+    required: ["amount", "interval"],
+    fields: {
+      interval: {
+        enum: ["one_off", "week", "month", "quarter", "semi_annual", "year"]
+      }
+    }
+  },
+  "plans.variants.customize.price.additionalCurrencies": {
+    required: ["amount", "currency"]
+  },
+  "plans.variants.customize.removeItems": {
+    fields: {
+      billingMethod: {
+        enum: ["prepaid", "usage_based"]
+      },
+      interval: {
+        enum: [
+          "one_off",
+          "week",
+          "month",
+          "quarter",
+          "semi_annual",
+          "year",
+          "minute",
+          "hour",
+          "day"
+        ]
+      },
+      intervalCount: {
+        minimum: -9007199254740991,
+        maximum: 9007199254740991,
+        exclusiveMinimum: 0
+      },
+      included: {
+        maximum: 10000000000000
+      }
+    }
+  },
+  "plans.variants.customize.removeLicenses": {
+    required: ["licensePlanId"]
+  },
+  "plans.variants.customize.upsertLicenses": {
+    required: ["licensePlanId"],
+    fields: {
+      included: {
+        minimum: 0,
+        maximum: 9007199254740991
+      }
+    }
+  },
+  "plans.variants.customize.upsertLicenses.customize.addItems": {
+    required: ["featureId"],
+    fields: {
+      included: {
+        maximum: 10000000000000
+      }
+    }
+  },
+  "plans.variants.customize.upsertLicenses.customize.addItems.featureOverride.creditSchema": {
+    variants: {
+      on: "tierBehavior",
+      byValue: {
+        graduated: {
+          required: ["meteredFeatureId", "tierBehavior", "tiers"],
+          fields: {
+            meteredFeatureId: {
+              minLength: 1
+            },
+            billingUnits: {
+              exclusiveMinimum: 0
+            },
+            tierBehavior: {
+              enum: ["graduated"]
+            },
+            tiers: {
+              minItems: 1
+            }
+          }
+        }
+      },
+      fallback: {
+        required: ["creditCost", "meteredFeatureId"],
+        fields: {
+          meteredFeatureId: {
+            minLength: 1
+          },
+          billingUnits: {
+            exclusiveMinimum: 0
+          },
+          creditCost: {
+            minimum: 0
+          }
+        }
+      }
+    }
+  },
+  "plans.variants.customize.upsertLicenses.customize.addItems.featureOverride.creditSchema.dimensions": {
+    keys: {
+      minLength: 1,
+      maxLength: 64
+    }
+  },
+  "plans.variants.customize.upsertLicenses.customize.addItems.featureOverride.creditSchema.dimensions.*": {
+    variants: {
+      on: "tierBehavior",
+      byValue: {
+        graduated: {
+          required: ["match", "tierBehavior", "tiers"],
+          fields: {
+            priority: {
+              minimum: -9007199254740991,
+              maximum: 9007199254740991
+            },
+            tierBehavior: {
+              enum: ["graduated"]
+            },
+            tiers: {
+              minItems: 1
+            }
+          }
+        }
+      },
+      fallback: {
+        required: ["creditCost", "match"],
+        fields: {
+          priority: {
+            minimum: -9007199254740991,
+            maximum: 9007199254740991
+          },
+          creditCost: {
+            minimum: 0
+          }
+        }
+      }
+    }
+  },
+  "plans.variants.customize.upsertLicenses.customize.addItems.featureOverride.creditSchema.dimensions.*.tiers": {
+    required: ["creditCost"],
+    fields: {
+      creditCost: {
+        minimum: 0
+      }
+    }
+  },
+  "plans.variants.customize.upsertLicenses.customize.addItems.featureOverride.creditSchema.multipliers": {
+    keys: {
+      minLength: 1,
+      maxLength: 64
+    }
+  },
+  "plans.variants.customize.upsertLicenses.customize.addItems.featureOverride.creditSchema.multipliers.*": {
+    required: ["match"],
+    fields: {
+      factor: {
+        exclusiveMinimum: 0
+      }
+    }
+  },
+  "plans.variants.customize.upsertLicenses.customize.addItems.featureOverride.creditSchema.tiers": {
+    required: ["creditCost", "to"],
+    fields: {
+      to: {
+        exclusiveMinimum: 0
+      },
+      creditCost: {
+        minimum: 0
+      }
+    }
+  },
+  "plans.variants.customize.upsertLicenses.customize.addItems.featureOverride.markups": {
+    fields: {
+      defaultMarkup: {
+        minimum: -100
+      }
+    }
+  },
+  "plans.variants.customize.upsertLicenses.customize.addItems.featureOverride.markups.modelMarkups": {
+    keys: {
+      pattern: ".+\\/.+"
+    }
+  },
+  "plans.variants.customize.upsertLicenses.customize.addItems.featureOverride.markups.modelMarkups.*": {
+    fields: {
+      markup: {
+        minimum: -100
+      },
+      inputCost: {
+        minimum: 0
+      },
+      outputCost: {
+        minimum: 0
+      }
+    }
+  },
+  "plans.variants.customize.upsertLicenses.customize.addItems.featureOverride.markups.providerMarkups.*": {
+    required: ["markup"],
+    fields: {
+      markup: {
+        minimum: -100
+      }
+    }
+  },
+  "plans.variants.customize.upsertLicenses.customize.addItems.price": {
+    required: ["billingMethod", "interval"],
+    fields: {
+      tierBehavior: {
+        enum: ["graduated", "volume"]
+      },
+      interval: {
+        enum: ["one_off", "week", "month", "quarter", "semi_annual", "year"]
+      },
+      billingMethod: {
+        enum: ["prepaid", "usage_based"]
+      },
+      allocatedBilling: {
+        enum: ["arrear", "prorated_legacy"]
+      }
+    }
+  },
+  "plans.variants.customize.upsertLicenses.customize.addItems.price.additionalCurrencies": {
+    required: ["amount", "currency"]
+  },
+  "plans.variants.customize.upsertLicenses.customize.addItems.price.tiers": {
+    required: ["to"]
+  },
+  "plans.variants.customize.upsertLicenses.customize.addItems.price.tiers.additionalCurrencies": {
+    required: ["currency"]
+  },
+  "plans.variants.customize.upsertLicenses.customize.addItems.proration": {
+    required: ["onDecrease", "onIncrease"],
+    fields: {
+      onIncrease: {
+        enum: [
+          "bill_immediately",
+          "prorate_immediately",
+          "prorate_next_cycle",
+          "bill_next_cycle"
+        ]
+      },
+      onDecrease: {
+        enum: [
+          "prorate",
+          "prorate_immediately",
+          "prorate_next_cycle",
+          "none",
+          "no_prorations"
+        ]
+      }
+    }
+  },
+  "plans.variants.customize.upsertLicenses.customize.addItems.reset": {
+    required: ["interval"],
+    fields: {
+      interval: {
+        enum: [
+          "one_off",
+          "minute",
+          "hour",
+          "day",
+          "week",
+          "month",
+          "quarter",
+          "semi_annual",
+          "year"
+        ]
+      }
+    }
+  },
+  "plans.variants.customize.upsertLicenses.customize.addItems.rollover": {
+    required: ["expiryDurationType"],
+    fields: {
+      expiryDurationType: {
+        enum: ["month", "forever"]
+      }
+    }
+  },
+  "plans.variants.customize.upsertLicenses.customize.addItems.thresholdBilling": {
+    required: ["threshold"],
+    fields: {
+      threshold: {
+        exclusiveMinimum: 0
+      }
+    }
+  },
+  "plans.variants.customize.upsertLicenses.customize.price": {
+    required: ["amount", "interval"],
+    fields: {
+      interval: {
+        enum: ["one_off", "week", "month", "quarter", "semi_annual", "year"]
+      }
+    }
+  },
+  "plans.variants.customize.upsertLicenses.customize.price.additionalCurrencies": {
+    required: ["amount", "currency"]
+  },
+  "plans.variants.customize.upsertLicenses.customize.removeItems": {
+    fields: {
+      billingMethod: {
+        enum: ["prepaid", "usage_based"]
+      },
+      interval: {
+        enum: [
+          "one_off",
+          "week",
+          "month",
+          "quarter",
+          "semi_annual",
+          "year",
+          "minute",
+          "hour",
+          "day"
+        ]
+      },
+      intervalCount: {
+        minimum: -9007199254740991,
+        maximum: 9007199254740991,
+        exclusiveMinimum: 0
+      },
+      included: {
+        maximum: 10000000000000
+      }
+    }
+  },
+  "plans.variants.processors.revenuecat": {
+    required: ["products"]
+  },
+  "plans.variants.processors.revenuecat.products": {
+    required: ["productId"]
+  },
+  "plans.variants.processors.revenuecat.products.featureQuantities": {
+    required: ["featureId"],
+    fields: {
+      quantity: {
+        minimum: 0
+      }
+    }
+  },
+  "plans.variants.processors.stripe": {
+    required: ["productId"]
+  },
+  referralPrograms: {
+    label: "referral program",
+    idField: "id",
+    required: ["id", "receivedBy", "redeemOn", "rewardId"],
+    fields: {
+      id: {
+        minLength: 1
+      },
+      rewardId: {
+        minLength: 1
+      },
+      redeemOn: {
+        enum: ["customer_creation", "checkout"]
+      },
+      receivedBy: {
+        enum: ["referrer", "all"]
+      },
+      maxRedemptions: {
+        minimum: -9007199254740991,
+        maximum: 9007199254740991,
+        exclusiveMinimum: 0
+      },
+      internalId: {
+        minLength: 1
+      }
+    },
+    rules: [
+      {
+        kind: "unique",
+        field: "id",
+        because: "Two referral programs claiming one id race to define the same row."
+      },
+      {
+        kind: "unique",
+        field: "internalId",
+        because: "A stable id names exactly one row; two fixtures cannot both be it."
+      },
+      {
+        kind: "exists",
+        field: "rewardId",
+        in: "rewards",
+        matching: ["coupon.id", "featureGrant.id"],
+        because: "A referral program grants a reward this config does not declare."
+      },
+      {
+        kind: "exists",
+        field: "planIds",
+        in: "plans",
+        matching: "planId",
+        because: "A referral program triggers on checkout of a plan this config does not declare."
+      }
+    ]
+  },
+  removeFeatures: {
+    required: ["featureId"]
+  },
+  removePlans: {
+    required: ["planId"],
+    fields: {
+      version: {
+        minimum: 1,
+        maximum: 9007199254740991
+      }
+    }
+  },
+  rewards: {
+    label: "reward",
+    rules: [
+      {
+        kind: "unique",
+        field: ["coupon.id", "featureGrant.id"],
+        because: "Two rewards claiming one id race to define the same row."
+      },
+      {
+        kind: "unique",
+        field: ["coupon.internalId", "featureGrant.internalId"],
+        because: "A stable id names exactly one row; two fixtures cannot both be it."
+      }
+    ]
+  },
+  "rewards.coupon": {
+    label: "coupon",
+    idField: "id",
+    required: [
+      "duration",
+      "id",
+      "name",
+      "planIds",
+      "promoCodes",
+      "type",
+      "value"
+    ],
+    fields: {
+      id: {
+        minLength: 1
+      },
+      name: {
+        minLength: 1
+      },
+      planIds: {
+        minItems: 1
+      },
+      internalId: {
+        minLength: 1
+      },
+      type: {
+        enum: ["percentage_discount", "fixed_discount"]
+      },
+      value: {
+        exclusiveMinimum: 0
+      }
+    },
+    rules: [
+      {
+        kind: "exists",
+        field: "planIds",
+        in: "plans",
+        matching: "planId",
+        because: "A coupon discounts a plan this config does not declare."
+      }
+    ]
+  },
+  "rewards.coupon.duration": {
+    required: ["length", "type"],
+    fields: {
+      type: {
+        enum: ["one_off", "months", "forever"]
+      },
+      length: {
+        minimum: -9007199254740991,
+        maximum: 9007199254740991,
+        exclusiveMinimum: 0
+      }
+    }
+  },
+  "rewards.coupon.promoCodes": {
+    required: ["code"],
+    fields: {
+      code: {
+        minLength: 1
+      },
+      globalMaxRedemption: {
+        minimum: -9007199254740991,
+        maximum: 9007199254740991,
+        exclusiveMinimum: 0
+      }
+    }
+  },
+  "rewards.featureGrant": {
+    label: "feature grant",
+    idField: "id",
+    required: ["grants", "id", "name", "promoCodes"],
+    fields: {
+      id: {
+        minLength: 1
+      },
+      name: {
+        minLength: 1
+      },
+      grants: {
+        minItems: 1
+      },
+      promoCodes: {
+        minItems: 1
+      },
+      internalId: {
+        minLength: 1
+      }
+    }
+  },
+  "rewards.featureGrant.grants": {
+    label: "grant",
+    idField: "featureId",
+    required: ["expiry", "featureId", "included"],
+    fields: {
+      featureId: {
+        minLength: 1
+      },
+      included: {
+        minimum: 0
+      }
+    },
+    rules: [
+      {
+        kind: "exists",
+        field: "featureId",
+        in: "features",
+        matching: "featureId",
+        because: "A feature grant awards a feature this config does not declare."
+      }
+    ]
+  },
+  "rewards.featureGrant.grants.expiry": {
+    required: ["length", "type"],
+    fields: {
+      type: {
+        enum: ["day", "week", "month", "year"]
+      },
+      length: {
+        minimum: -9007199254740991,
+        maximum: 9007199254740991,
+        exclusiveMinimum: 0
+      }
+    }
+  },
+  "rewards.featureGrant.promoCodes": {
+    required: ["code", "maxUses"],
+    fields: {
+      code: {
+        minLength: 1
+      },
+      maxUses: {
+        minimum: -9007199254740991,
+        maximum: 9007199254740991,
+        exclusiveMinimum: 0
+      }
+    }
+  }
+};
+
+// src/generated/lintRuntime.ts
+class ConfigError extends Error {
+  issues;
+  constructor(issues) {
+    super([
+      `${issues.length} problem${issues.length === 1 ? "" : "s"} in your config:`,
+      "",
+      ...issues.map((issue) => `  ${issue.path}
+    ${issue.message}`)
+    ].join(`
+`));
+    this.name = "ConfigError";
+    this.issues = issues;
+  }
+}
+var isEntry = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var valueAtPath = ({
+  entry,
+  path
+}) => {
+  let current = entry;
+  for (const segment of path.split(".")) {
+    if (!isEntry(current))
+      return;
+    current = current[segment];
+  }
+  return current;
+};
+var firstValueAtPaths = ({
+  entry,
+  paths
+}) => {
+  for (const path of typeof paths === "string" ? [paths] : paths) {
+    const value = valueAtPath({ entry, path });
+    if (value !== undefined)
+      return value;
+  }
+  return;
+};
+var show = (value) => JSON.stringify(value);
+var list = (values) => values.map(show).join(", ");
+var regexCache = new Map;
+var regexFor = (pattern) => {
+  const cached = regexCache.get(pattern);
+  if (cached)
+    return cached;
+  const compiled = new RegExp(pattern);
+  regexCache.set(pattern, compiled);
+  return compiled;
+};
+var constraintFailures = ({
+  name,
+  value,
+  constraints
+}) => {
+  const failures = [];
+  const c = constraints;
+  if (c.enum && !c.enum.includes(value)) {
+    failures.push(`${name} must be one of ${list(c.enum)} — got ${show(value)}.`);
+  }
+  if (typeof value === "number") {
+    if (c.minimum !== undefined && value < c.minimum)
+      failures.push(`${name} must be at least ${c.minimum} — got ${value}.`);
+    if (c.maximum !== undefined && value > c.maximum)
+      failures.push(`${name} must be at most ${c.maximum} — got ${value}.`);
+    if (c.exclusiveMinimum !== undefined && value <= c.exclusiveMinimum)
+      failures.push(`${name} must be greater than ${c.exclusiveMinimum} — got ${value}.`);
+    if (c.exclusiveMaximum !== undefined && value >= c.exclusiveMaximum)
+      failures.push(`${name} must be less than ${c.exclusiveMaximum} — got ${value}.`);
+  }
+  if (typeof value === "string") {
+    if (c.minLength !== undefined && value.length < c.minLength) {
+      failures.push(c.minLength === 1 ? `${name} must not be empty.` : `${name} must be at least ${c.minLength} characters — got ${value.length}.`);
+    }
+    if (c.maxLength !== undefined && value.length > c.maxLength)
+      failures.push(`${name} must be at most ${c.maxLength} characters — got ${value.length}.`);
+    if (c.pattern !== undefined && !regexFor(c.pattern).test(value))
+      failures.push(`${name} must match ${c.pattern} — got ${show(value)}.`);
+  }
+  if (Array.isArray(value)) {
+    if (c.minItems !== undefined && value.length < c.minItems)
+      failures.push(`${name} must have at least ${c.minItems} ${c.minItems === 1 ? "entry" : "entries"}.`);
+    if (c.maxItems !== undefined && value.length > c.maxItems)
+      failures.push(`${name} must have at most ${c.maxItems} entries.`);
+  }
+  return failures;
+};
+var checkShape = ({
+  entry,
+  shape,
+  at,
+  issues
+}) => {
+  for (const field of shape.required ?? []) {
+    if (entry[field] === undefined)
+      issues.push({ path: at, message: `${field} is required.` });
+  }
+  for (const [field, constraints] of Object.entries(shape.fields ?? {})) {
+    if (entry[field] === undefined)
+      continue;
+    for (const message of constraintFailures({
+      name: field,
+      value: entry[field],
+      constraints
+    })) {
+      issues.push({ path: at, message });
+    }
+  }
+};
+var checkVariants = ({
+  entry,
+  variants,
+  at,
+  issues
+}) => {
+  const selector = entry[variants.on];
+  if (selector === undefined) {
+    if (variants.fallback) {
+      checkShape({ entry, shape: variants.fallback, at, issues });
+    } else {
+      issues.push({ path: at, message: `${variants.on} is required.` });
+    }
+    return;
+  }
+  const chosen = typeof selector === "string" ? variants.byValue[selector] : undefined;
+  if (!chosen) {
+    issues.push({
+      path: at,
+      message: `${variants.on} must be one of ${list(Object.keys(variants.byValue))} — got ${show(selector)}.`
+    });
+    return;
+  }
+  checkShape({ entry, shape: chosen, at, issues });
+};
+var crumbFor = ({
+  node,
+  key,
+  entry,
+  index
+}) => {
+  const label = node?.label ?? key;
+  const id = node?.idField ? entry[node.idField] : undefined;
+  return typeof id === "string" && id ? `${label} ${show(id)}` : `${label}[${index}]`;
+};
+var render = (trail) => trail.length === 0 ? "config" : trail.join(" › ");
+var setFields = ({
+  entry,
+  fields
+}) => fields.filter((field) => entry[field] !== undefined);
+var joinNames = (names) => names.length <= 1 ? names.join("") : `${names.slice(0, -1).join(", ")} and ${names[names.length - 1]}`;
+var COMPARE = {
+  "<": { holds: (a, b) => a < b, words: "less than" },
+  "<=": { holds: (a, b) => a <= b, words: "at most" },
+  ">": { holds: (a, b) => a > b, words: "greater than" },
+  ">=": { holds: (a, b) => a >= b, words: "at least" }
+};
+var entryRuleFailures = ({
+  entry,
+  rule,
+  document,
+  parent
+}) => {
+  switch (rule.kind) {
+    case "requiredWhen": {
+      if (entry[rule.when] !== rule.equals)
+        return [];
+      return rule.require.filter((field) => entry[field] === undefined).map((field) => `${field} is required when ${rule.when} is ${show(rule.equals)}. ${rule.because}`);
+    }
+    case "forbiddenWhen": {
+      if (entry[rule.when] !== rule.equals)
+        return [];
+      return setFields({ entry, fields: rule.forbid }).map((field) => `${field} cannot be set when ${rule.when} is ${show(rule.equals)}. ${rule.because}`);
+    }
+    case "mutex": {
+      const set = setFields({ entry, fields: rule.fields });
+      if (set.length <= 1)
+        return [];
+      return [`${joinNames(set)} cannot be set together. ${rule.because}`];
+    }
+    case "exactlyOne": {
+      const set = setFields({ entry, fields: rule.fields });
+      if (set.length === 1)
+        return [];
+      if (set.length === 0)
+        return [
+          `One of ${joinNames(rule.fields)} is required. ${rule.because}`
+        ];
+      return [`${joinNames(set)} cannot be set together. ${rule.because}`];
+    }
+    case "exists": {
+      const value = valueAtPath({ entry, path: rule.field });
+      const target = document[rule.in];
+      if (value === undefined || value === null || !Array.isArray(target))
+        return [];
+      const names = (wanted) => target.some((candidate) => isEntry(candidate) && firstValueAtPaths({ entry: candidate, paths: rule.matching }) === wanted);
+      const missing = (Array.isArray(value) ? value : [value]).filter((wanted) => !names(wanted));
+      return missing.map((wanted) => `${rule.field} ${show(wanted)} is not in ${rule.in}. ${rule.because}`);
+    }
+    case "compare": {
+      const a = entry[rule.field];
+      const b = entry[rule.than];
+      if (typeof a !== "number" || typeof b !== "number")
+        return [];
+      const { holds, words } = COMPARE[rule.op];
+      return holds(a, b) ? [] : [
+        `${rule.field} must be ${words} ${rule.than} — got ${a} and ${b}. ${rule.because}`
+      ];
+    }
+    case "valueWhen": {
+      if (entry[rule.when] !== rule.equals)
+        return [];
+      const value = entry[rule.field];
+      if (value === undefined || value === rule.mustBe)
+        return [];
+      return [
+        `${rule.field} must be ${show(rule.mustBe)} when ${rule.when} is ${show(rule.equals)}. ${rule.because}`
+      ];
+    }
+    case "targetHas": {
+      if (entry[rule.when] === undefined)
+        return [];
+      const target = document[rule.in];
+      if (!Array.isArray(target))
+        return [];
+      const row = target.find((candidate) => isEntry(candidate) && candidate[rule.matching] === entry[rule.field]);
+      if (!row || row[rule.target] === rule.equals)
+        return [];
+      return [
+        `${rule.when} needs ${rule.in} ${show(entry[rule.field])} to have ${rule.target} ${show(rule.equals)} — got ${show(row[rule.target])}. ${rule.because}`
+      ];
+    }
+    case "targetLacks": {
+      const target = document[rule.in];
+      if (!Array.isArray(target))
+        return [];
+      const row = target.find((candidate) => isEntry(candidate) && candidate[rule.matching] === entry[rule.field]);
+      if (!row || row[rule.target] !== true)
+        return [];
+      if (parent?.[rule.parentGuard] === true)
+        return [];
+      return [
+        `${rule.label} ${show(entry[rule.field])} is ${rule.target}. Unarchive it, or archive ${rule.parentLabel} ${show(parent?.[rule.parentIdField])}. ${rule.because}`
+      ];
+    }
+    case "unique":
+    case "linkedOnce":
+    case "exactlyOneActive":
+      return [];
+  }
+};
+var checkUnique = ({
+  entries,
+  rule,
+  node,
+  key,
+  trail,
+  issues
+}) => {
+  const seen = new Set;
+  for (const [index, entry] of entries.entries()) {
+    if (!isEntry(entry))
+      continue;
+    const value = firstValueAtPaths({ entry, paths: rule.field });
+    if (typeof value !== "string")
+      continue;
+    const fieldName = typeof rule.field === "string" ? rule.field : rule.field.join(" / ");
+    const pair = rule.alongside === undefined ? undefined : entry[rule.alongside];
+    if (rule.alongside !== undefined && typeof pair !== "string")
+      continue;
+    const composite = rule.alongside === undefined ? value : `${value}@${pair}`;
+    if (seen.has(composite)) {
+      const label = rule.alongside === undefined ? `${fieldName} ${show(value)}` : `${fieldName} ${show(value)} with ${rule.alongside} ${show(pair)}`;
+      issues.push({
+        path: render([...trail, crumbFor({ node, key, entry, index })]),
+        message: `${label} is used more than once. ${rule.because}`
+      });
+    }
+    seen.add(composite);
+  }
+};
+var pinOf = ({
+  entry,
+  pins
+}) => {
+  for (const pin of pins) {
+    const value = entry[pin];
+    if (typeof value === "string")
+      return { key: `${pin}:${value}`, display: value };
+    if (typeof value === "number")
+      return { key: `${pin}:${value}`, display: `v${value}` };
+  }
+  return;
+};
+var checkLinkedOnce = ({
+  entries,
+  rule,
+  node,
+  key,
+  trail,
+  issues
+}) => {
+  const ownerByLink = new Map;
+  for (const [index, entry] of entries.entries()) {
+    if (!isEntry(entry))
+      continue;
+    const group = entry[rule.groupBy];
+    const links = entry[rule.collection];
+    if (typeof group !== "string" || !Array.isArray(links))
+      continue;
+    const owner = pinOf({ entry, pins: [rule.namedBy] })?.display ?? rule.absentMeans;
+    for (const link of links) {
+      if (!isEntry(link))
+        continue;
+      const id = link[rule.identity];
+      if (typeof id !== "string")
+        continue;
+      const pin = pinOf({ entry: link, pins: rule.pins });
+      const label = pin === undefined ? id : `${id} ${pin.display}`;
+      const composite = `${group} ${id} ${pin?.key ?? "latest"}`;
+      const previous = ownerByLink.get(composite);
+      if (previous === undefined) {
+        ownerByLink.set(composite, { owner, index });
+        continue;
+      }
+      const at = render([...trail, crumbFor({ node, key, entry, index })]);
+      if (previous.index === index) {
+        issues.push({
+          path: at,
+          message: `${label} is linked twice from ${group} ${owner}. ${rule.because}`
+        });
+        continue;
+      }
+      if (previous.owner === owner)
+        continue;
+      issues.push({
+        path: at,
+        message: `${label} is linked from ${group} ${previous.owner} and ${group} ${owner}. ${rule.because}`
+      });
+    }
+  }
+};
+var checkExactlyOneActive = ({
+  entries,
+  rule,
+  node,
+  key,
+  trail,
+  issues
+}) => {
+  const rowsByGroup = new Map;
+  for (const [index, entry] of entries.entries()) {
+    if (!isEntry(entry))
+      continue;
+    const group = entry[rule.groupBy];
+    if (typeof group !== "string")
+      continue;
+    rowsByGroup.set(group, [
+      ...rowsByGroup.get(group) ?? [],
+      { entry, index, active: entry[rule.field] === true }
+    ]);
+  }
+  for (const [group, members] of rowsByGroup) {
+    const active = members.filter((member) => member.active);
+    if (active.length === 1)
+      continue;
+    const at = active.length === 0 ? members[0] : active[1];
+    if (at === undefined)
+      continue;
+    const versions = `${members.length} version${members.length === 1 ? "" : "s"}`;
+    const count = active.length === 0 ? "none is active" : `${active.length} are active`;
+    issues.push({
+      path: render([
+        ...trail,
+        crumbFor({ node, key, entry: at.entry, index: at.index })
+      ]),
+      message: `${rule.label} ${show(group)} has ${versions} and ${count}. ${rule.because}${renameHint({ active, members })}`
+    });
+  }
+};
+var renameHint = ({
+  active,
+  members
+}) => {
+  if (active.length !== 0)
+    return "";
+  const everyRowIsKnown = members.every((member) => typeof member.entry.internalId === "string");
+  if (!everyRowIsKnown)
+    return "";
+  return " If you are renaming a plan, change the planId on every one of its versions, not just some.";
+};
+var checkCollection = ({
+  entries,
+  node,
+  key,
+  trail,
+  issues
+}) => {
+  for (const rule of node.rules ?? []) {
+    if (rule.kind === "unique")
+      checkUnique({ entries, rule, node, key, trail, issues });
+    if (rule.kind === "linkedOnce")
+      checkLinkedOnce({ entries, rule, node, key, trail, issues });
+    if (rule.kind === "exactlyOneActive")
+      checkExactlyOneActive({ entries, rule, node, key, trail, issues });
+  }
+};
+var checkEntry = ({
+  entry,
+  node,
+  at,
+  walk,
+  parent
+}) => {
+  checkShape({ entry, shape: node, at, issues: walk.issues });
+  if (node.variants) {
+    checkVariants({ entry, variants: node.variants, at, issues: walk.issues });
+  }
+  for (const rule of node.rules ?? []) {
+    for (const message of entryRuleFailures({
+      entry,
+      rule,
+      document: walk.document,
+      parent
+    })) {
+      walk.issues.push({ path: at, message });
+    }
+  }
+};
+var walkEntry = ({
+  entry,
+  path,
+  trail,
+  walk,
+  parent
+}) => {
+  const node = walk.rules[path];
+  if (node)
+    checkEntry({ entry, node, at: render(trail), walk, parent });
+  for (const [key, child] of Object.entries(entry)) {
+    walkValue({
+      value: child,
+      path: path ? `${path}.${key}` : key,
+      key,
+      trail,
+      walk,
+      parent: entry
+    });
+  }
+};
+var walkValue = ({
+  value,
+  path,
+  key,
+  trail,
+  walk,
+  parent
+}) => {
+  if (walk.hints.frozenPaths.has(path))
+    return;
+  if (Array.isArray(value)) {
+    const node = walk.rules[path];
+    if (node) {
+      checkCollection({
+        entries: value,
+        node,
+        key,
+        trail,
+        issues: walk.issues
+      });
+    }
+    for (const [index, entry] of value.entries()) {
+      if (!isEntry(entry))
+        continue;
+      walkEntry({
+        entry,
+        path,
+        trail: [...trail, crumbFor({ node, key, entry, index })],
+        walk,
+        parent
+      });
+    }
+    return;
+  }
+  if (!isEntry(value))
+    return;
+  if (walk.hints.recordPaths.has(path)) {
+    const keys = walk.rules[path]?.keys;
+    for (const [recordKey, child] of Object.entries(value)) {
+      if (keys) {
+        for (const message of constraintFailures({
+          name: `${key} key ${show(recordKey)}`,
+          value: recordKey,
+          constraints: keys
+        })) {
+          walk.issues.push({ path: render(trail), message });
+        }
+      }
+      walkValue({
+        value: child,
+        path: `${path}.*`,
+        key: `${key}[${show(recordKey)}]`,
+        trail,
+        walk,
+        parent
+      });
+    }
+    return;
+  }
+  walkEntry({ entry: value, path, trail: [...trail, key], walk, parent });
+};
+var lintDocument = ({
+  document,
+  rules,
+  hints
+}) => {
+  const walk = { document, rules, hints, issues: [] };
+  walkEntry({ entry: document, path: "", trail: [], walk });
+  return walk.issues;
+};
+
+// src/generated/wire.ts
+var isOperatorKey = (key) => key.startsWith("$");
+var toSnakeCase = (key) => isOperatorKey(key) ? key : key.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`);
+var toCamelCase = (key) => isOperatorKey(key) ? key : key.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+var clearOmittedRelationshipCustomizes = (row) => {
+  if (row === null || typeof row !== "object")
+    return row;
+  const source = row;
+  const normalize = (entries) => Array.isArray(entries) ? entries.map((entry) => entry !== null && typeof entry === "object" ? {
+    ...entry,
+    customize: entry.customize ?? null
+  } : entry) : entries;
+  return {
+    ...source,
+    ...source.licenses !== undefined ? { licenses: normalize(source.licenses) } : {},
+    ...source.variants !== undefined ? { variants: normalize(source.variants) } : {}
+  };
+};
+var toWire = ({
+  value,
+  path,
+  hints
+}) => {
+  if (hints.frozenPaths.has(path))
+    return value;
+  if (Array.isArray(value)) {
+    return value.map((entry) => toWire({ value: entry, path, hints }));
+  }
+  if (value === null || typeof value !== "object")
+    return value;
+  const source = value;
+  if (hints.recordPaths.has(path)) {
+    return Object.fromEntries(Object.entries(source).map(([key, entry]) => [
+      key,
+      toWire({ value: entry, path: `${path}.*`, hints })
+    ]));
+  }
+  return Object.fromEntries(Object.entries(source).map(([key, entry]) => {
+    const childPath = path ? `${path}.${key}` : key;
+    return [
+      hints.renamedPaths.get(childPath) ?? toSnakeCase(key),
+      toWire({ value: entry, path: childPath, hints })
+    ];
+  }));
+};
+var toFixture = ({
+  value,
+  path,
+  hints
+}) => {
+  if (hints.frozenPaths.has(path))
+    return value;
+  if (Array.isArray(value)) {
+    return value.map((entry) => toFixture({ value: entry, path, hints }));
+  }
+  if (value === null || typeof value !== "object")
+    return value;
+  const source = value;
+  if (hints.recordPaths.has(path)) {
+    return Object.fromEntries(Object.entries(source).map(([key, entry]) => [
+      key,
+      toFixture({ value: entry, path: `${path}.*`, hints })
+    ]));
+  }
+  return Object.fromEntries(Object.entries(source).map(([key, entry]) => {
+    const name = hints.renamedWirePaths.get(path ? `${path}.${key}` : key) ?? toCamelCase(key);
+    return [
+      name,
+      toFixture({
+        value: entry,
+        path: path ? `${path}.${name}` : name,
+        hints
+      })
+    ];
+  }));
+};
+var hintsOf = (hints) => ({
+  recordPaths: new Set(hints.recordPaths),
+  frozenPaths: new Set(hints.frozenPaths),
+  renamedPaths: new Map(Object.entries(hints.renamedPaths)),
+  renamedWirePaths: new Map(Object.entries(hints.renamedPaths).map(([fixturePath, wireKey]) => {
+    const segments = fixturePath.split(".");
+    const parent = segments.slice(0, -1);
+    return [
+      [...parent, wireKey].join("."),
+      segments[segments.length - 1] ?? ""
+    ];
+  }))
+});
+var CATALOG_HINTS = hintsOf({
+  recordPaths: [
+    "features.creditSchema.dimensions",
+    "features.creditSchema.dimensions.*.match",
+    "features.creditSchema.multipliers",
+    "features.creditSchema.multipliers.*.match",
+    "features.modelMarkups",
+    "features.providerMarkups",
+    "plans.billingControls.usageAlerts.filter.properties",
+    "plans.billingControls.usageLimits.filter.properties",
+    "plans.items.featureOverride.creditSchema.dimensions",
+    "plans.items.featureOverride.creditSchema.dimensions.*.match",
+    "plans.items.featureOverride.creditSchema.multipliers",
+    "plans.items.featureOverride.creditSchema.multipliers.*.match",
+    "plans.items.featureOverride.markups.modelMarkups",
+    "plans.items.featureOverride.markups.providerMarkups",
+    "plans.licenses.customize.addItems.featureOverride.creditSchema.dimensions",
+    "plans.licenses.customize.addItems.featureOverride.creditSchema.dimensions.*.match",
+    "plans.licenses.customize.addItems.featureOverride.creditSchema.multipliers",
+    "plans.licenses.customize.addItems.featureOverride.creditSchema.multipliers.*.match",
+    "plans.licenses.customize.addItems.featureOverride.markups.modelMarkups",
+    "plans.licenses.customize.addItems.featureOverride.markups.providerMarkups",
+    "plans.variants.customize.addItems.featureOverride.creditSchema.dimensions",
+    "plans.variants.customize.addItems.featureOverride.creditSchema.dimensions.*.match",
+    "plans.variants.customize.addItems.featureOverride.creditSchema.multipliers",
+    "plans.variants.customize.addItems.featureOverride.creditSchema.multipliers.*.match",
+    "plans.variants.customize.addItems.featureOverride.markups.modelMarkups",
+    "plans.variants.customize.addItems.featureOverride.markups.providerMarkups",
+    "plans.variants.customize.billingControls.usageAlerts.filter.properties",
+    "plans.variants.customize.billingControls.usageLimits.filter.properties",
+    "plans.variants.customize.items.featureOverride.creditSchema.dimensions",
+    "plans.variants.customize.items.featureOverride.creditSchema.dimensions.*.match",
+    "plans.variants.customize.items.featureOverride.creditSchema.multipliers",
+    "plans.variants.customize.items.featureOverride.creditSchema.multipliers.*.match",
+    "plans.variants.customize.items.featureOverride.markups.modelMarkups",
+    "plans.variants.customize.items.featureOverride.markups.providerMarkups",
+    "plans.variants.customize.upsertLicenses.customize.addItems.featureOverride.creditSchema.dimensions",
+    "plans.variants.customize.upsertLicenses.customize.addItems.featureOverride.creditSchema.dimensions.*.match",
+    "plans.variants.customize.upsertLicenses.customize.addItems.featureOverride.creditSchema.multipliers",
+    "plans.variants.customize.upsertLicenses.customize.addItems.featureOverride.creditSchema.multipliers.*.match",
+    "plans.variants.customize.upsertLicenses.customize.addItems.featureOverride.markups.modelMarkups",
+    "plans.variants.customize.upsertLicenses.customize.addItems.featureOverride.markups.providerMarkups"
+  ],
+  frozenPaths: [
+    "plans.licenses.metadata",
+    "plans.metadata",
+    "plans.variants.customize.upsertLicenses.metadata"
+  ],
+  renamedPaths: { "settings.paydownOverages": "persist_free_overage" }
+});
+var stated = (config) => ({
+  ...config.features !== undefined ? { features: config.features } : {},
+  ...config.plans !== undefined ? {
+    plans: config.plans.map(clearOmittedRelationshipCustomizes),
+    skip_version_deletions: false
+  } : {},
+  ...config.rewards !== undefined ? { rewards: config.rewards } : {},
+  ...config.referralPrograms !== undefined ? { referralPrograms: config.referralPrograms } : {},
+  ...config.settings !== undefined ? { settings: config.settings } : {}
+});
+var SINGLETON_KEYS = ["settings"];
+var CONFIG_KEYS = [
+  "features",
+  "plans",
+  "rewards",
+  "referralPrograms",
+  "settings"
+];
+var unknownKeyIssue = (key) => key === "planVersions" ? {
+  path: key,
+  message: "planVersions is gone: every version is now a row in plans, with versionSlug and active. Rebuild the config from your org with `atmn pull --overwrite --yes` (commit first), or move the rows into plans."
+} : {
+  path: key,
+  message: `${key} is not a config field. The fields are ${CONFIG_KEYS.join(", ")}.`
+};
+var splitWire = (document) => ({
+  catalog: Object.fromEntries(Object.entries(document).filter(([key]) => !SINGLETON_KEYS.includes(key))),
+  singletons: {
+    settings: document.settings === undefined ? undefined : { config: document.settings }
+  }
+});
+var atmn = (config) => {
+  const unknownKeys = Object.keys(config).filter((key) => !CONFIG_KEYS.includes(key));
+  if (unknownKeys.length > 0)
+    throw new ConfigError(unknownKeys.map(unknownKeyIssue));
+  const document = stated(config);
+  const issues = lintDocument({
+    document,
+    rules: LINT_RULES,
+    hints: CATALOG_HINTS
+  });
+  if (issues.length > 0)
+    throw new ConfigError(issues);
+  return {
+    ...toWire({
+      value: document,
+      path: "",
+      hints: CATALOG_HINTS
+    }),
+    skip_deletions: false,
+    migration: { draft: true }
+  };
+};
+export {
+  variant,
+  referralProgram,
+  plan,
+  license,
+  featureGrant,
+  feature,
+  coupon,
+  atmn
+};