import { r as _, a as A, b as P, c as R, d as O, e as q, f as M, g as I } from "./index-BkQ7xHgi.js";
import { r as N, a as S, b as C } from "./index-LUItEwlw.js";
function D(o, e) {
  for (var n = 0; n < e.length; n++) {
    const t = e[n];
    if (typeof t != "string" && !Array.isArray(t)) {
      for (const r in t)
        if (r !== "default" && !(r in o)) {
          const s = Object.getOwnPropertyDescriptor(t, r);
          s && Object.defineProperty(o, r, s.get ? s : {
            enumerable: !0,
            get: () => t[r]
          });
        }
    }
  }
  return Object.freeze(Object.defineProperty(o, Symbol.toStringTag, { value: "Module" }));
}
var f = { exports: {} }, m = {};
const E = "https://json-schema.org/draft/2019-09/schema", V = "https://json-schema.org/draft/2019-09/schema", w = { "https://json-schema.org/draft/2019-09/vocab/core": !0, "https://json-schema.org/draft/2019-09/vocab/applicator": !0, "https://json-schema.org/draft/2019-09/vocab/validation": !0, "https://json-schema.org/draft/2019-09/vocab/meta-data": !0, "https://json-schema.org/draft/2019-09/vocab/format": !1, "https://json-schema.org/draft/2019-09/vocab/content": !0 }, T = !0, x = "Core and Validation specifications meta-schema", k = [{ $ref: "meta/core" }, { $ref: "meta/applicator" }, { $ref: "meta/validation" }, { $ref: "meta/meta-data" }, { $ref: "meta/format" }, { $ref: "meta/content" }], K = ["object", "boolean"], z = { definitions: { $comment: "While no longer an official keyword as it is replaced by $defs, this keyword is retained in the meta-schema to prevent incompatible extensions as it remains in common use.", type: "object", additionalProperties: { $recursiveRef: "#" }, default: {} }, dependencies: { $comment: '"dependencies" is no longer a keyword, but schema authors should avoid redefining it to facilitate a smooth transition to "dependentSchemas" and "dependentRequired"', type: "object", additionalProperties: { anyOf: [{ $recursiveRef: "#" }, { $ref: "meta/validation#/$defs/stringArray" }] } } }, G = {
  $schema: E,
  $id: V,
  $vocabulary: w,
  $recursiveAnchor: T,
  title: x,
  allOf: k,
  type: K,
  properties: z
}, F = "https://json-schema.org/draft/2019-09/schema", J = "https://json-schema.org/draft/2019-09/meta/applicator", L = { "https://json-schema.org/draft/2019-09/vocab/applicator": !0 }, U = !0, Z = "Applicator vocabulary meta-schema", H = ["object", "boolean"], W = { additionalItems: { $recursiveRef: "#" }, unevaluatedItems: { $recursiveRef: "#" }, items: { anyOf: [{ $recursiveRef: "#" }, { $ref: "#/$defs/schemaArray" }] }, contains: { $recursiveRef: "#" }, additionalProperties: { $recursiveRef: "#" }, unevaluatedProperties: { $recursiveRef: "#" }, properties: { type: "object", additionalProperties: { $recursiveRef: "#" }, default: {} }, patternProperties: { type: "object", additionalProperties: { $recursiveRef: "#" }, propertyNames: { format: "regex" }, default: {} }, dependentSchemas: { type: "object", additionalProperties: { $recursiveRef: "#" } }, propertyNames: { $recursiveRef: "#" }, if: { $recursiveRef: "#" }, then: { $recursiveRef: "#" }, else: { $recursiveRef: "#" }, allOf: { $ref: "#/$defs/schemaArray" }, anyOf: { $ref: "#/$defs/schemaArray" }, oneOf: { $ref: "#/$defs/schemaArray" }, not: { $recursiveRef: "#" } }, B = { schemaArray: { type: "array", minItems: 1, items: { $recursiveRef: "#" } } }, Q = {
  $schema: F,
  $id: J,
  $vocabulary: L,
  $recursiveAnchor: U,
  title: Z,
  type: H,
  properties: W,
  $defs: B
}, X = "https://json-schema.org/draft/2019-09/schema", Y = "https://json-schema.org/draft/2019-09/meta/content", ee = { "https://json-schema.org/draft/2019-09/vocab/content": !0 }, te = !0, re = "Content vocabulary meta-schema", ae = ["object", "boolean"], oe = { contentMediaType: { type: "string" }, contentEncoding: { type: "string" }, contentSchema: { $recursiveRef: "#" } }, ne = {
  $schema: X,
  $id: Y,
  $vocabulary: ee,
  $recursiveAnchor: te,
  title: re,
  type: ae,
  properties: oe
}, se = "https://json-schema.org/draft/2019-09/schema", ie = "https://json-schema.org/draft/2019-09/meta/core", ce = { "https://json-schema.org/draft/2019-09/vocab/core": !0 }, ue = !0, de = "Core vocabulary meta-schema", fe = ["object", "boolean"], me = { $id: { type: "string", format: "uri-reference", $comment: "Non-empty fragments not allowed.", pattern: "^[^#]*#?$" }, $schema: { type: "string", format: "uri" }, $anchor: { type: "string", pattern: "^[A-Za-z][-A-Za-z0-9.:_]*$" }, $ref: { type: "string", format: "uri-reference" }, $recursiveRef: { type: "string", format: "uri-reference" }, $recursiveAnchor: { type: "boolean", default: !1 }, $vocabulary: { type: "object", propertyNames: { type: "string", format: "uri" }, additionalProperties: { type: "boolean" } }, $comment: { type: "string" }, $defs: { type: "object", additionalProperties: { $recursiveRef: "#" }, default: {} } }, $e = {
  $schema: se,
  $id: ie,
  $vocabulary: ce,
  $recursiveAnchor: ue,
  title: de,
  type: fe,
  properties: me
}, le = "https://json-schema.org/draft/2019-09/schema", pe = "https://json-schema.org/draft/2019-09/meta/format", he = { "https://json-schema.org/draft/2019-09/vocab/format": !0 }, ye = !0, ve = "Format vocabulary meta-schema", ge = ["object", "boolean"], be = { format: { type: "string" } }, je = {
  $schema: le,
  $id: pe,
  $vocabulary: he,
  $recursiveAnchor: ye,
  title: ve,
  type: ge,
  properties: be
}, _e = "https://json-schema.org/draft/2019-09/schema", Ae = "https://json-schema.org/draft/2019-09/meta/meta-data", Pe = { "https://json-schema.org/draft/2019-09/vocab/meta-data": !0 }, Re = !0, Oe = "Meta-data vocabulary meta-schema", qe = ["object", "boolean"], Me = { title: { type: "string" }, description: { type: "string" }, default: !0, deprecated: { type: "boolean", default: !1 }, readOnly: { type: "boolean", default: !1 }, writeOnly: { type: "boolean", default: !1 }, examples: { type: "array", items: !0 } }, Ie = {
  $schema: _e,
  $id: Ae,
  $vocabulary: Pe,
  $recursiveAnchor: Re,
  title: Oe,
  type: qe,
  properties: Me
}, Ne = "https://json-schema.org/draft/2019-09/schema", Se = "https://json-schema.org/draft/2019-09/meta/validation", Ce = { "https://json-schema.org/draft/2019-09/vocab/validation": !0 }, De = !0, Ee = "Validation vocabulary meta-schema", Ve = ["object", "boolean"], we = { multipleOf: { type: "number", exclusiveMinimum: 0 }, maximum: { type: "number" }, exclusiveMaximum: { type: "number" }, minimum: { type: "number" }, exclusiveMinimum: { type: "number" }, maxLength: { $ref: "#/$defs/nonNegativeInteger" }, minLength: { $ref: "#/$defs/nonNegativeIntegerDefault0" }, pattern: { type: "string", format: "regex" }, maxItems: { $ref: "#/$defs/nonNegativeInteger" }, minItems: { $ref: "#/$defs/nonNegativeIntegerDefault0" }, uniqueItems: { type: "boolean", default: !1 }, maxContains: { $ref: "#/$defs/nonNegativeInteger" }, minContains: { $ref: "#/$defs/nonNegativeInteger", default: 1 }, maxProperties: { $ref: "#/$defs/nonNegativeInteger" }, minProperties: { $ref: "#/$defs/nonNegativeIntegerDefault0" }, required: { $ref: "#/$defs/stringArray" }, dependentRequired: { type: "object", additionalProperties: { $ref: "#/$defs/stringArray" } }, const: !0, enum: { type: "array", items: !0 }, type: { anyOf: [{ $ref: "#/$defs/simpleTypes" }, { type: "array", items: { $ref: "#/$defs/simpleTypes" }, minItems: 1, uniqueItems: !0 }] } }, Te = { nonNegativeInteger: { type: "integer", minimum: 0 }, nonNegativeIntegerDefault0: { $ref: "#/$defs/nonNegativeInteger", default: 0 }, simpleTypes: { enum: ["array", "boolean", "integer", "null", "number", "object", "string"] }, stringArray: { type: "array", items: { type: "string" }, uniqueItems: !0, default: [] } }, xe = {
  $schema: Ne,
  $id: Se,
  $vocabulary: Ce,
  $recursiveAnchor: De,
  title: Ee,
  type: Ve,
  properties: we,
  $defs: Te
};
var h;
function ke() {
  if (h) return m;
  h = 1, Object.defineProperty(m, "__esModule", { value: !0 });
  const o = G, e = Q, n = ne, t = $e, r = je, s = Ie, $ = xe, l = ["/properties"];
  function p(c) {
    return [
      o,
      e,
      n,
      t,
      i(this, r),
      s,
      i(this, $)
    ].forEach((u) => this.addMetaSchema(u, void 0, !1)), this;
    function i(u, a) {
      return c ? u.$dataMetaSchema(a, l) : a;
    }
  }
  return m.default = p, m;
}
var y;
function Ke() {
  return y || (y = 1, function(o, e) {
    Object.defineProperty(e, "__esModule", { value: !0 }), e.MissingRefError = e.ValidationError = e.CodeGen = e.Name = e.nil = e.stringify = e.str = e._ = e.KeywordCxt = e.Ajv2019 = void 0;
    const n = _(), t = A(), r = N(), s = S(), $ = C(), l = P(), p = ke(), c = "https://json-schema.org/draft/2019-09/schema";
    class i extends n.default {
      constructor(d = {}) {
        super({
          ...d,
          dynamicRef: !0,
          next: !0,
          unevaluated: !0
        });
      }
      _addVocabularies() {
        super._addVocabularies(), this.addVocabulary(r.default), t.default.forEach((d) => this.addVocabulary(d)), this.addVocabulary(s.default), this.addVocabulary($.default), this.opts.discriminator && this.addKeyword(l.default);
      }
      _addDefaultMetaSchema() {
        super._addDefaultMetaSchema();
        const { $data: d, meta: j } = this.opts;
        j && (p.default.call(this, d), this.refs["http://json-schema.org/schema"] = c);
      }
      defaultMeta() {
        return this.opts.defaultMeta = super.defaultMeta() || (this.getSchema(c) ? c : void 0);
      }
    }
    e.Ajv2019 = i, o.exports = e = i, o.exports.Ajv2019 = i, Object.defineProperty(e, "__esModule", { value: !0 }), e.default = i;
    var u = R();
    Object.defineProperty(e, "KeywordCxt", { enumerable: !0, get: function() {
      return u.KeywordCxt;
    } });
    var a = O();
    Object.defineProperty(e, "_", { enumerable: !0, get: function() {
      return a._;
    } }), Object.defineProperty(e, "str", { enumerable: !0, get: function() {
      return a.str;
    } }), Object.defineProperty(e, "stringify", { enumerable: !0, get: function() {
      return a.stringify;
    } }), Object.defineProperty(e, "nil", { enumerable: !0, get: function() {
      return a.nil;
    } }), Object.defineProperty(e, "Name", { enumerable: !0, get: function() {
      return a.Name;
    } }), Object.defineProperty(e, "CodeGen", { enumerable: !0, get: function() {
      return a.CodeGen;
    } });
    var g = q();
    Object.defineProperty(e, "ValidationError", { enumerable: !0, get: function() {
      return g.default;
    } });
    var b = M();
    Object.defineProperty(e, "MissingRefError", { enumerable: !0, get: function() {
      return b.default;
    } });
  }(f, f.exports)), f.exports;
}
var v = Ke();
const ze = /* @__PURE__ */ I(v), Le = /* @__PURE__ */ D({
  __proto__: null,
  default: ze
}, [v]);
export {
  Le as _
};
