{"version":3,"sources":["../../../src/schema/types/number-old.ts"],"sourcesContent":["import Decimal              from '../../core/decimal/decimal'\r\nimport Definitions          from '../../core/definitions'\r\nimport InternetObjectError  from '../../errors/io-error'\r\nimport ErrorCodes           from '../../errors/io-error-codes'\r\nimport ValidationError      from '../../errors/io-validation-error'\r\nimport Node                 from '../../parser/nodes/nodes'\r\nimport Schema               from '../../schema/schema'\r\nimport TypeDef              from '../../schema/typedef'\r\nimport doCommonTypeCheck    from './common-type'\r\nimport MemberDef            from './memberdef'\r\n\r\n\r\nconst NUMBER_TYPES = [\r\n  'bigint', 'decimal',\r\n  'int', 'uint', 'float', 'number',       // General number types\r\n  'int8', 'int16', 'int32',               // Size specific number types\r\n  'uint8', 'uint16', 'uint32', 'uint64',  // Unsigned number types\r\n  'float32', 'float64'                    // Floating point number types\r\n]\r\n\r\nconst NUMBER_MAP = NUMBER_TYPES.reduce((acc, type) => {\r\n  acc[type] = true\r\n  return acc\r\n}, {} as { [key: string]: boolean })\r\n\r\nconst numberSchema = new Schema(\r\n  \"number\",\r\n  { type:     { type: \"string\", optional: false, null: false, choices: NUMBER_TYPES } },\r\n  { default:  { type: \"number\", optional: true,  null: false  } },\r\n  { choices:  { type: \"array\",  optional: true,  null: false, of: { type: \"number\" } } },\r\n  { min:      { type: \"number\", optional: true,  null: false, min: 0 } },\r\n  { max:      { type: \"number\", optional: true,  null: false, min: 0 } },\r\n  { format:   { type: \"string\", optional: true, null: false, choices: [\"decimal\", \"hex\", \"octal\", \"binary\", \"scientific\"] } },\r\n  { optional: { type: \"bool\",   optional: true } },\r\n  { null:     { type: \"bool\",   optional: true } },\r\n)\r\n\r\nconst bigintSchema = new Schema(\r\n  \"bigint\",\r\n  { type:     { type: \"string\", optional: false, null: false, choices: NUMBER_TYPES } },\r\n  { default:  { type: \"bigint\", optional: true,  null: false  } },\r\n  { choices:  { type: \"array\",  optional: true,  null: false, of: { type: \"bigint\" } } },\r\n  { min:      { type: \"bigint\", optional: true,  null: false, min: 0 } },\r\n  { max:      { type: \"bigint\", optional: true,  null: false, min: 0 } },\r\n  { format:   { type: \"string\", optional: true,  null: false, choices: [\"decimal\", \"hex\", \"octal\", \"binary\"], default:\"decimal\" } },\r\n  { optional: { type: \"bool\",   optional: true } },\r\n  { null:     { type: \"bool\",   optional: true } },\r\n)\r\n\r\nconst decimalSchema = new Schema(\r\n  \"bigint\",\r\n  { type:       { type: \"string\", optional: false, null: false, choices: NUMBER_TYPES } },\r\n  { default:    { type: \"decimal\", optional: true,  null: false  } },\r\n  { choices:    { type: \"array\",  optional: true,  null: false, of: { type: \"decimal\" } } },\r\n  { precision:  { type: \"number\", optional: true, null: false } },\r\n  { scale:      { type: \"number\", optional: true, null: false } },\r\n  { min:        { type: \"decimal\", optional: true,  null: false, min: 0 } },\r\n  { max:        { type: \"decimal\", optional: true,  null: false, min: 0 } },\r\n  { optional:   { type: \"bool\",   optional: true } },\r\n  { null:       { type: \"bool\",   optional: true } },\r\n)\r\n\r\n/**\r\n * Represents the various number related data types in Internet Object.\r\n *\r\n * @internal\r\n */\r\nclass NumberDef implements TypeDef {\r\n  private _type: string;\r\n  private _validator: any;\r\n\r\n  get type(): string { return this._type; }\r\n  get schema(): Schema {\r\n    if (this._type === 'bigint') {\r\n      return bigintSchema;\r\n    } else if (this._type === 'decimal') {\r\n      return decimalSchema;\r\n    }\r\n\r\n    return numberSchema;\r\n  }\r\n\r\n  constructor(type: string = 'number') {\r\n    this._type = type;\r\n    this._validator = _getValidator(type);\r\n  }\r\n\r\n  parse(node: Node, memberDef: MemberDef, defs?: Definitions): number {\r\n    const valueNode = defs?.getV(node) || node;\r\n    let { value, changed } = doCommonTypeCheck(memberDef, valueNode, node, defs);\r\n    if (changed) return value;\r\n\r\n    value = this._validator(memberDef, value, node);\r\n\r\n    return value;\r\n  }\r\n\r\n  stringify(value: any, memberDef: MemberDef): string {\r\n    if (memberDef.format === 'decimal') { return value.toString(); }\r\n    if (memberDef.format === 'scientific') { return value.toExponential(); }\r\n    if (memberDef.format === 'hex') { return value.toString(16); }\r\n    if (memberDef.format === 'octal') { return value.toString(8); }\r\n    if (memberDef.format === 'binary') { return value.toString(2); }\r\n\r\n    return value.toString();\r\n  }\r\n\r\n  static get types() {\r\n    return NUMBER_TYPES;\r\n  }\r\n}\r\n\r\n// Helper function for throwing validation errors\r\nfunction throwError(code: string, memberPath: string, value: any, node?: Node) {\r\n  throw new ValidationError(\r\n    code,\r\n    `The '${memberPath}' must be within the specified range, Currently it is ${value}.`,\r\n    node\r\n  );\r\n}\r\n\r\nfunction _intValidator(min: number | null, max: number | null, memberDef: MemberDef, value: any, node?: Node): (number | bigint | Decimal) {\r\n  const valueType = typeof value === \"bigint\" ? \"bigint\" : NUMBER_MAP[typeof value] ? \"number\" : \"\";\r\n  const memberdefType = memberDef.type === \"bigint\" ? \"bigint\" : \"number\";\r\n\r\n  if (valueType === \"\") {\r\n    throw new ValidationError(\r\n      ErrorCodes.invalidType,\r\n      `Expecting a value of type '${memberDef.type}' for '${memberDef.path}'`,\r\n      node\r\n    );\r\n  }\r\n\r\n  if (memberdefType !== valueType) {\r\n    throw new ValidationError(\r\n      `not-a-${memberDef.type}`,\r\n      `Invalid value encountered for '${memberDef.path}'`,\r\n      node\r\n    )\r\n  }\r\n\r\n  // Use memberDef.min/max if available, otherwise use bound min/max\r\n  const effectiveMin = memberDef.min !== undefined && memberDef.min !== null ? memberDef.min : min;\r\n  const effectiveMax = memberDef.max !== undefined && memberDef.max !== null ? memberDef.max : max;\r\n\r\n  if ((effectiveMin !== null && value < effectiveMin) || (effectiveMax !== null && value > effectiveMax)) {\r\n    throwError(ErrorCodes.invalidRange, memberDef.path!, value, node);\r\n  }\r\n\r\n  return value;\r\n}\r\n\r\n// Helper function to get the number of integer digits in a decimal\r\nfunction getIntegerDigits(decimal: Decimal): number {\r\n  const valueStr = decimal.toString();\r\n  return valueStr.split('.')[0].replace('-', '').length;\r\n}\r\n\r\nfunction _decimalValidator(memberDef: MemberDef, value: any, node?: Node): (number | bigint | Decimal) {\r\n\r\n  const { min, max, precision: requiredPrecision, scale: requiredScale } = memberDef;\r\n\r\n  const valD: Decimal = Decimal.ensureDecimal(value);\r\n\r\n  // Mode check: Determine validation mode based on precision and scale\r\n  const hasRequiredPrecision = requiredPrecision !== null && requiredPrecision !== undefined;\r\n  const hasRequiredScale = requiredScale !== null && requiredScale !== undefined;\r\n\r\n  // Validate scale if specified (modes 2 and 4)\r\n  if (hasRequiredScale) {\r\n    const actualScale = valD.getScale();\r\n    if (actualScale !== requiredScale) {\r\n      throwError(\r\n        ErrorCodes.invalidScale,\r\n        memberDef.path!,\r\n        `Value has scale ${actualScale}, expected ${requiredScale}`,\r\n        node\r\n      );\r\n    }\r\n  }\r\n\r\n  // Validate precision if specified (modes 3 and 4)\r\n  if (hasRequiredPrecision) {\r\n    const actualPrecision = valD.getPrecision();\r\n\r\n    if (hasRequiredScale) {\r\n      // Mode 4: Strict validation (both precision and scale)\r\n      // Check if value fits within DECIMAL(precision, scale)\r\n      const intDigits = getIntegerDigits(valD);\r\n      const maxIntDigits = requiredPrecision - requiredScale;\r\n\r\n      if (intDigits > maxIntDigits) {\r\n        throwError(\r\n          ErrorCodes.invalidPrecision,\r\n          memberDef.path!,\r\n          `Integer part has ${intDigits} digits, DECIMAL(${requiredPrecision},${requiredScale}) allows ${maxIntDigits}`,\r\n          node\r\n        );\r\n      }\r\n    } else {\r\n      // Mode 3: Precision-only validation\r\n      if (actualPrecision > requiredPrecision) {\r\n        throwError(\r\n          ErrorCodes.invalidPrecision,\r\n          memberDef.path!,\r\n          `Value has precision ${actualPrecision}, max allowed is ${requiredPrecision}`,\r\n          node\r\n        );\r\n      }\r\n    }\r\n  }\r\n\r\n  // Validate min constraint - normalize to same scale for comparison\r\n  if (min !== null && min !== undefined) {\r\n    const minD: Decimal = Decimal.ensureDecimal(min);\r\n\r\n    // Use the larger scale for both\r\n    const targetScale = Math.max(valD.getScale(), minD.getScale());\r\n\r\n    // Calculate precision needed: max integer digits + target scale\r\n    const valIntDigits = getIntegerDigits(valD);\r\n    const minIntDigits = getIntegerDigits(minD);\r\n    const targetPrecision = Math.max(valIntDigits, minIntDigits) + targetScale;\r\n\r\n    const normalizedVal = valD.convert(targetPrecision, targetScale);\r\n    const normalizedMin = minD.convert(targetPrecision, targetScale);\r\n\r\n    if (normalizedVal.compareTo(normalizedMin) < 0) {\r\n      throwError(ErrorCodes.invalidRange, memberDef.path!, value, node);\r\n    }\r\n  }\r\n\r\n  // Validate max constraint - normalize to same scale for comparison\r\n  if (max !== null && max !== undefined) {\r\n    const maxD: Decimal = Decimal.ensureDecimal(max);\r\n\r\n    // Use the larger scale for both\r\n    const targetScale = Math.max(valD.getScale(), maxD.getScale());\r\n\r\n    // Calculate precision needed: max integer digits + target scale\r\n    const valIntDigits = getIntegerDigits(valD);\r\n    const maxIntDigits = getIntegerDigits(maxD);\r\n    const targetPrecision = Math.max(valIntDigits, maxIntDigits) + targetScale;\r\n\r\n    const normalizedVal = valD.convert(targetPrecision, targetScale);\r\n    const normalizedMax = maxD.convert(targetPrecision, targetScale);\r\n\r\n    if (normalizedVal.compareTo(normalizedMax) > 0) {\r\n      throwError(ErrorCodes.invalidRange, memberDef.path!, value, node);\r\n    }\r\n  }\r\n\r\n  // Return the value as-is (don't convert unless necessary)\r\n  // If precision/scale were specified for validation, the value already passed those checks\r\n  return valD;\r\n}\r\n\r\nfunction _getValidator(type: string) {\r\n  switch (type) {\r\n    case 'float':\r\n    case 'float64':\r\n    case 'number':\r\n    case 'bigint':\r\n    case 'int':\r\n      return _intValidator.bind(null, null, null);\r\n\r\n    case 'uint':\r\n      return _intValidator.bind(null, 0, null);\r\n\r\n    case 'int8':\r\n      return _intValidator.bind(null, -(2 ** 7), 2 ** 7 - 1);\r\n\r\n    case 'uint8':\r\n      return _intValidator.bind(null, 0, 2 ** 8 - 1);\r\n\r\n    case 'int16':\r\n      return _intValidator.bind(null, -(2 ** 15), 2 ** 15 - 1);\r\n\r\n    case 'uint16':\r\n      return _intValidator.bind(null, 0, 2 ** 16 - 1);\r\n\r\n    case 'int32':\r\n      return _intValidator.bind(null, -(2 ** 31), 2 ** 31 - 1);\r\n\r\n    case 'uint32':\r\n      return _intValidator.bind(null, 0, 2 ** 32 - 1);\r\n\r\n    case 'uint64':\r\n    case 'int64':\r\n    case 'float32':\r\n    case 'float64':\r\n      return (memberDef: MemberDef, value: any, node?: Node) => {\r\n        throw new InternetObjectError(ErrorCodes.unsupportedNumberType, `The number type '${type}' is not supported.`);\r\n      }\r\n\r\n    case 'decimal':\r\n      return (memberDef: MemberDef, value: any, node?: Node) => {\r\n        const { min, max, precision: requiredPrecision, scale: requiredScale } = memberDef;\r\n        const valD: Decimal = Decimal.ensureDecimal(value);\r\n\r\n        // Mode check: Determine validation mode based on precision and scale\r\n        const hasRequiredPrecision = requiredPrecision !== null && requiredPrecision !== undefined;\r\n        const hasRequiredScale = requiredScale !== null && requiredScale !== undefined;\r\n\r\n        // Validate scale if specified (modes 2 and 4)\r\n        if (hasRequiredScale) {\r\n          const actualScale = valD.getScale();\r\n          if (actualScale !== requiredScale) {\r\n            throwError(\r\n              ErrorCodes.invalidScale,\r\n              memberDef.path!,\r\n              `Value has scale ${actualScale}, expected ${requiredScale}`,\r\n              node\r\n            );\r\n          }\r\n        }\r\n\r\n        // Validate precision if specified (modes 3 and 4)\r\n        if (hasRequiredPrecision) {\r\n          const actualPrecision = valD.getPrecision();\r\n\r\n          if (hasRequiredScale) {\r\n            // Mode 4: Strict validation (both precision and scale)\r\n            // Check if value fits within DECIMAL(precision, scale)\r\n            const intDigits = getIntegerDigits(valD);\r\n            const maxIntDigits = requiredPrecision - requiredScale;\r\n\r\n            if (intDigits > maxIntDigits) {\r\n              throwError(\r\n                ErrorCodes.invalidPrecision,\r\n                memberDef.path!,\r\n                `Integer part has ${intDigits} digits, DECIMAL(${requiredPrecision},${requiredScale}) allows ${maxIntDigits}`,\r\n                node\r\n              );\r\n            }\r\n          } else {\r\n            // Mode 3: Precision-only validation\r\n            if (actualPrecision > requiredPrecision) {\r\n              throwError(\r\n                ErrorCodes.invalidPrecision,\r\n                memberDef.path!,\r\n                `Value has precision ${actualPrecision}, max allowed is ${requiredPrecision}`,\r\n                node\r\n              );\r\n            }\r\n          }\r\n        }\r\n\r\n        // Validate min constraint - normalize to same scale for comparison\r\n        if (min !== null && min !== undefined) {\r\n          const minD: Decimal = Decimal.ensureDecimal(min);\r\n\r\n          // Use the larger scale for both\r\n          const targetScale = Math.max(valD.getScale(), minD.getScale());\r\n\r\n          // Calculate precision needed: max integer digits + target scale\r\n          const valIntDigits = getIntegerDigits(valD);\r\n          const minIntDigits = getIntegerDigits(minD);\r\n          const targetPrecision = Math.max(valIntDigits, minIntDigits) + targetScale;\r\n\r\n          const normalizedVal = valD.convert(targetPrecision, targetScale);\r\n          const normalizedMin = minD.convert(targetPrecision, targetScale);\r\n\r\n          if (normalizedVal.compareTo(normalizedMin) < 0) {\r\n            throwError(ErrorCodes.invalidRange, memberDef.path!, value, node);\r\n          }\r\n        }\r\n\r\n        // Validate max constraint - normalize to same scale for comparison\r\n        if (max !== null && max !== undefined) {\r\n          const maxD: Decimal = Decimal.ensureDecimal(max);\r\n\r\n          // Use the larger scale for both\r\n          const targetScale = Math.max(valD.getScale(), maxD.getScale());\r\n\r\n          // Calculate precision needed: max integer digits + target scale\r\n          const valIntDigits = getIntegerDigits(valD);\r\n          const maxIntDigits = getIntegerDigits(maxD);\r\n          const targetPrecision = Math.max(valIntDigits, maxIntDigits) + targetScale;\r\n\r\n          const normalizedVal = valD.convert(targetPrecision, targetScale);\r\n          const normalizedMax = maxD.convert(targetPrecision, targetScale);\r\n\r\n          if (normalizedVal.compareTo(normalizedMax) > 0) {\r\n            throwError(ErrorCodes.invalidRange, memberDef.path!, value, node);\r\n          }\r\n        }\r\n\r\n        // Return the value as-is (don't convert unless necessary)\r\n        return valD;\r\n      }\r\n\r\n    default:\r\n      throw new InternetObjectError(ErrorCodes.invalidType, `The number type '${type}' is not a valid number type.`);\r\n  }\r\n}\r\n\r\nexport default NumberDef\r\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,qBAAiC;AAEjC,sBAAiC;AACjC,4BAAiC;AACjC,iCAAiC;AAEjC,oBAAiC;AAEjC,yBAAiC;AAIjC,MAAM,eAAe;AAAA,EACnB;AAAA,EAAU;AAAA,EACV;AAAA,EAAO;AAAA,EAAQ;AAAA,EAAS;AAAA;AAAA,EACxB;AAAA,EAAQ;AAAA,EAAS;AAAA;AAAA,EACjB;AAAA,EAAS;AAAA,EAAU;AAAA,EAAU;AAAA;AAAA,EAC7B;AAAA,EAAW;AAAA;AACb;AAEA,MAAM,aAAa,aAAa,OAAO,CAAC,KAAK,SAAS;AACpD,MAAI,IAAI,IAAI;AACZ,SAAO;AACT,GAAG,CAAC,CAA+B;AAEnC,MAAM,eAAe,IAAI,cAAAA;AAAA,EACvB;AAAA,EACA,EAAE,MAAU,EAAE,MAAM,UAAU,UAAU,OAAO,MAAM,OAAO,SAAS,aAAa,EAAE;AAAA,EACpF,EAAE,SAAU,EAAE,MAAM,UAAU,UAAU,MAAO,MAAM,MAAO,EAAE;AAAA,EAC9D,EAAE,SAAU,EAAE,MAAM,SAAU,UAAU,MAAO,MAAM,OAAO,IAAI,EAAE,MAAM,SAAS,EAAE,EAAE;AAAA,EACrF,EAAE,KAAU,EAAE,MAAM,UAAU,UAAU,MAAO,MAAM,OAAO,KAAK,EAAE,EAAE;AAAA,EACrE,EAAE,KAAU,EAAE,MAAM,UAAU,UAAU,MAAO,MAAM,OAAO,KAAK,EAAE,EAAE;AAAA,EACrE,EAAE,QAAU,EAAE,MAAM,UAAU,UAAU,MAAM,MAAM,OAAO,SAAS,CAAC,WAAW,OAAO,SAAS,UAAU,YAAY,EAAE,EAAE;AAAA,EAC1H,EAAE,UAAU,EAAE,MAAM,QAAU,UAAU,KAAK,EAAE;AAAA,EAC/C,EAAE,MAAU,EAAE,MAAM,QAAU,UAAU,KAAK,EAAE;AACjD;AAEA,MAAM,eAAe,IAAI,cAAAA;AAAA,EACvB;AAAA,EACA,EAAE,MAAU,EAAE,MAAM,UAAU,UAAU,OAAO,MAAM,OAAO,SAAS,aAAa,EAAE;AAAA,EACpF,EAAE,SAAU,EAAE,MAAM,UAAU,UAAU,MAAO,MAAM,MAAO,EAAE;AAAA,EAC9D,EAAE,SAAU,EAAE,MAAM,SAAU,UAAU,MAAO,MAAM,OAAO,IAAI,EAAE,MAAM,SAAS,EAAE,EAAE;AAAA,EACrF,EAAE,KAAU,EAAE,MAAM,UAAU,UAAU,MAAO,MAAM,OAAO,KAAK,EAAE,EAAE;AAAA,EACrE,EAAE,KAAU,EAAE,MAAM,UAAU,UAAU,MAAO,MAAM,OAAO,KAAK,EAAE,EAAE;AAAA,EACrE,EAAE,QAAU,EAAE,MAAM,UAAU,UAAU,MAAO,MAAM,OAAO,SAAS,CAAC,WAAW,OAAO,SAAS,QAAQ,GAAG,SAAQ,UAAU,EAAE;AAAA,EAChI,EAAE,UAAU,EAAE,MAAM,QAAU,UAAU,KAAK,EAAE;AAAA,EAC/C,EAAE,MAAU,EAAE,MAAM,QAAU,UAAU,KAAK,EAAE;AACjD;AAEA,MAAM,gBAAgB,IAAI,cAAAA;AAAA,EACxB;AAAA,EACA,EAAE,MAAY,EAAE,MAAM,UAAU,UAAU,OAAO,MAAM,OAAO,SAAS,aAAa,EAAE;AAAA,EACtF,EAAE,SAAY,EAAE,MAAM,WAAW,UAAU,MAAO,MAAM,MAAO,EAAE;AAAA,EACjE,EAAE,SAAY,EAAE,MAAM,SAAU,UAAU,MAAO,MAAM,OAAO,IAAI,EAAE,MAAM,UAAU,EAAE,EAAE;AAAA,EACxF,EAAE,WAAY,EAAE,MAAM,UAAU,UAAU,MAAM,MAAM,MAAM,EAAE;AAAA,EAC9D,EAAE,OAAY,EAAE,MAAM,UAAU,UAAU,MAAM,MAAM,MAAM,EAAE;AAAA,EAC9D,EAAE,KAAY,EAAE,MAAM,WAAW,UAAU,MAAO,MAAM,OAAO,KAAK,EAAE,EAAE;AAAA,EACxE,EAAE,KAAY,EAAE,MAAM,WAAW,UAAU,MAAO,MAAM,OAAO,KAAK,EAAE,EAAE;AAAA,EACxE,EAAE,UAAY,EAAE,MAAM,QAAU,UAAU,KAAK,EAAE;AAAA,EACjD,EAAE,MAAY,EAAE,MAAM,QAAU,UAAU,KAAK,EAAE;AACnD;AAOA,MAAM,UAA6B;AAAA,EACzB;AAAA,EACA;AAAA,EAER,IAAI,OAAe;AAAE,WAAO,KAAK;AAAA,EAAO;AAAA,EACxC,IAAI,SAAiB;AACnB,QAAI,KAAK,UAAU,UAAU;AAC3B,aAAO;AAAA,IACT,WAAW,KAAK,UAAU,WAAW;AACnC,aAAO;AAAA,IACT;AAEA,WAAO;AAAA,EACT;AAAA,EAEA,YAAY,OAAe,UAAU;AACnC,SAAK,QAAQ;AACb,SAAK,aAAa,cAAc,IAAI;AAAA,EACtC;AAAA,EAEA,MAAM,MAAY,WAAsB,MAA4B;AAClE,UAAM,YAAY,MAAM,KAAK,IAAI,KAAK;AACtC,QAAI,EAAE,OAAO,QAAQ,QAAI,mBAAAC,SAAkB,WAAW,WAAW,MAAM,IAAI;AAC3E,QAAI,QAAS,QAAO;AAEpB,YAAQ,KAAK,WAAW,WAAW,OAAO,IAAI;AAE9C,WAAO;AAAA,EACT;AAAA,EAEA,UAAU,OAAY,WAA8B;AAClD,QAAI,UAAU,WAAW,WAAW;AAAE,aAAO,MAAM,SAAS;AAAA,IAAG;AAC/D,QAAI,UAAU,WAAW,cAAc;AAAE,aAAO,MAAM,cAAc;AAAA,IAAG;AACvE,QAAI,UAAU,WAAW,OAAO;AAAE,aAAO,MAAM,SAAS,EAAE;AAAA,IAAG;AAC7D,QAAI,UAAU,WAAW,SAAS;AAAE,aAAO,MAAM,SAAS,CAAC;AAAA,IAAG;AAC9D,QAAI,UAAU,WAAW,UAAU;AAAE,aAAO,MAAM,SAAS,CAAC;AAAA,IAAG;AAE/D,WAAO,MAAM,SAAS;AAAA,EACxB;AAAA,EAEA,WAAW,QAAQ;AACjB,WAAO;AAAA,EACT;AACF;AAGA,SAAS,WAAW,MAAc,YAAoB,OAAY,MAAa;AAC7E,QAAM,IAAI,2BAAAC;AAAA,IACR;AAAA,IACA,QAAQ,UAAU,yDAAyD,KAAK;AAAA,IAChF;AAAA,EACF;AACF;AAEA,SAAS,cAAc,KAAoB,KAAoB,WAAsB,OAAY,MAA0C;AACzI,QAAM,YAAY,OAAO,UAAU,WAAW,WAAW,WAAW,OAAO,KAAK,IAAI,WAAW;AAC/F,QAAM,gBAAgB,UAAU,SAAS,WAAW,WAAW;AAE/D,MAAI,cAAc,IAAI;AACpB,UAAM,IAAI,2BAAAA;AAAA,MACR,sBAAAC,QAAW;AAAA,MACX,8BAA8B,UAAU,IAAI,UAAU,UAAU,IAAI;AAAA,MACpE;AAAA,IACF;AAAA,EACF;AAEA,MAAI,kBAAkB,WAAW;AAC/B,UAAM,IAAI,2BAAAD;AAAA,MACR,SAAS,UAAU,IAAI;AAAA,MACvB,kCAAkC,UAAU,IAAI;AAAA,MAChD;AAAA,IACF;AAAA,EACF;AAGA,QAAM,eAAe,UAAU,QAAQ,UAAa,UAAU,QAAQ,OAAO,UAAU,MAAM;AAC7F,QAAM,eAAe,UAAU,QAAQ,UAAa,UAAU,QAAQ,OAAO,UAAU,MAAM;AAE7F,MAAK,iBAAiB,QAAQ,QAAQ,gBAAkB,iBAAiB,QAAQ,QAAQ,cAAe;AACtG,eAAW,sBAAAC,QAAW,cAAc,UAAU,MAAO,OAAO,IAAI;AAAA,EAClE;AAEA,SAAO;AACT;AAGA,SAAS,iBAAiB,SAA0B;AAClD,QAAM,WAAW,QAAQ,SAAS;AAClC,SAAO,SAAS,MAAM,GAAG,EAAE,CAAC,EAAE,QAAQ,KAAK,EAAE,EAAE;AACjD;AAEA,SAAS,kBAAkB,WAAsB,OAAY,MAA0C;AAErG,QAAM,EAAE,KAAK,KAAK,WAAW,mBAAmB,OAAO,cAAc,IAAI;AAEzE,QAAM,OAAgB,eAAAC,QAAQ,cAAc,KAAK;AAGjD,QAAM,uBAAuB,sBAAsB,QAAQ,sBAAsB;AACjF,QAAM,mBAAmB,kBAAkB,QAAQ,kBAAkB;AAGrE,MAAI,kBAAkB;AACpB,UAAM,cAAc,KAAK,SAAS;AAClC,QAAI,gBAAgB,eAAe;AACjC;AAAA,QACE,sBAAAD,QAAW;AAAA,QACX,UAAU;AAAA,QACV,mBAAmB,WAAW,cAAc,aAAa;AAAA,QACzD;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAGA,MAAI,sBAAsB;AACxB,UAAM,kBAAkB,KAAK,aAAa;AAE1C,QAAI,kBAAkB;AAGpB,YAAM,YAAY,iBAAiB,IAAI;AACvC,YAAM,eAAe,oBAAoB;AAEzC,UAAI,YAAY,cAAc;AAC5B;AAAA,UACE,sBAAAA,QAAW;AAAA,UACX,UAAU;AAAA,UACV,oBAAoB,SAAS,oBAAoB,iBAAiB,IAAI,aAAa,YAAY,YAAY;AAAA,UAC3G;AAAA,QACF;AAAA,MACF;AAAA,IACF,OAAO;AAEL,UAAI,kBAAkB,mBAAmB;AACvC;AAAA,UACE,sBAAAA,QAAW;AAAA,UACX,UAAU;AAAA,UACV,uBAAuB,eAAe,oBAAoB,iBAAiB;AAAA,UAC3E;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAGA,MAAI,QAAQ,QAAQ,QAAQ,QAAW;AACrC,UAAM,OAAgB,eAAAC,QAAQ,cAAc,GAAG;AAG/C,UAAM,cAAc,KAAK,IAAI,KAAK,SAAS,GAAG,KAAK,SAAS,CAAC;AAG7D,UAAM,eAAe,iBAAiB,IAAI;AAC1C,UAAM,eAAe,iBAAiB,IAAI;AAC1C,UAAM,kBAAkB,KAAK,IAAI,cAAc,YAAY,IAAI;AAE/D,UAAM,gBAAgB,KAAK,QAAQ,iBAAiB,WAAW;AAC/D,UAAM,gBAAgB,KAAK,QAAQ,iBAAiB,WAAW;AAE/D,QAAI,cAAc,UAAU,aAAa,IAAI,GAAG;AAC9C,iBAAW,sBAAAD,QAAW,cAAc,UAAU,MAAO,OAAO,IAAI;AAAA,IAClE;AAAA,EACF;AAGA,MAAI,QAAQ,QAAQ,QAAQ,QAAW;AACrC,UAAM,OAAgB,eAAAC,QAAQ,cAAc,GAAG;AAG/C,UAAM,cAAc,KAAK,IAAI,KAAK,SAAS,GAAG,KAAK,SAAS,CAAC;AAG7D,UAAM,eAAe,iBAAiB,IAAI;AAC1C,UAAM,eAAe,iBAAiB,IAAI;AAC1C,UAAM,kBAAkB,KAAK,IAAI,cAAc,YAAY,IAAI;AAE/D,UAAM,gBAAgB,KAAK,QAAQ,iBAAiB,WAAW;AAC/D,UAAM,gBAAgB,KAAK,QAAQ,iBAAiB,WAAW;AAE/D,QAAI,cAAc,UAAU,aAAa,IAAI,GAAG;AAC9C,iBAAW,sBAAAD,QAAW,cAAc,UAAU,MAAO,OAAO,IAAI;AAAA,IAClE;AAAA,EACF;AAIA,SAAO;AACT;AAEA,SAAS,cAAc,MAAc;AACnC,UAAQ,MAAM;AAAA,IACZ,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AACH,aAAO,cAAc,KAAK,MAAM,MAAM,IAAI;AAAA,IAE5C,KAAK;AACH,aAAO,cAAc,KAAK,MAAM,GAAG,IAAI;AAAA,IAEzC,KAAK;AACH,aAAO,cAAc,KAAK,MAAM,EAAE,KAAK,IAAI,KAAK,IAAI,CAAC;AAAA,IAEvD,KAAK;AACH,aAAO,cAAc,KAAK,MAAM,GAAG,KAAK,IAAI,CAAC;AAAA,IAE/C,KAAK;AACH,aAAO,cAAc,KAAK,MAAM,EAAE,KAAK,KAAK,KAAK,KAAK,CAAC;AAAA,IAEzD,KAAK;AACH,aAAO,cAAc,KAAK,MAAM,GAAG,KAAK,KAAK,CAAC;AAAA,IAEhD,KAAK;AACH,aAAO,cAAc,KAAK,MAAM,EAAE,KAAK,KAAK,KAAK,KAAK,CAAC;AAAA,IAEzD,KAAK;AACH,aAAO,cAAc,KAAK,MAAM,GAAG,KAAK,KAAK,CAAC;AAAA,IAEhD,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AACH,aAAO,CAAC,WAAsB,OAAY,SAAgB;AACxD,cAAM,IAAI,gBAAAE,QAAoB,sBAAAF,QAAW,uBAAuB,oBAAoB,IAAI,qBAAqB;AAAA,MAC/G;AAAA,IAEF,KAAK;AACH,aAAO,CAAC,WAAsB,OAAY,SAAgB;AACxD,cAAM,EAAE,KAAK,KAAK,WAAW,mBAAmB,OAAO,cAAc,IAAI;AACzE,cAAM,OAAgB,eAAAC,QAAQ,cAAc,KAAK;AAGjD,cAAM,uBAAuB,sBAAsB,QAAQ,sBAAsB;AACjF,cAAM,mBAAmB,kBAAkB,QAAQ,kBAAkB;AAGrE,YAAI,kBAAkB;AACpB,gBAAM,cAAc,KAAK,SAAS;AAClC,cAAI,gBAAgB,eAAe;AACjC;AAAA,cACE,sBAAAD,QAAW;AAAA,cACX,UAAU;AAAA,cACV,mBAAmB,WAAW,cAAc,aAAa;AAAA,cACzD;AAAA,YACF;AAAA,UACF;AAAA,QACF;AAGA,YAAI,sBAAsB;AACxB,gBAAM,kBAAkB,KAAK,aAAa;AAE1C,cAAI,kBAAkB;AAGpB,kBAAM,YAAY,iBAAiB,IAAI;AACvC,kBAAM,eAAe,oBAAoB;AAEzC,gBAAI,YAAY,cAAc;AAC5B;AAAA,gBACE,sBAAAA,QAAW;AAAA,gBACX,UAAU;AAAA,gBACV,oBAAoB,SAAS,oBAAoB,iBAAiB,IAAI,aAAa,YAAY,YAAY;AAAA,gBAC3G;AAAA,cACF;AAAA,YACF;AAAA,UACF,OAAO;AAEL,gBAAI,kBAAkB,mBAAmB;AACvC;AAAA,gBACE,sBAAAA,QAAW;AAAA,gBACX,UAAU;AAAA,gBACV,uBAAuB,eAAe,oBAAoB,iBAAiB;AAAA,gBAC3E;AAAA,cACF;AAAA,YACF;AAAA,UACF;AAAA,QACF;AAGA,YAAI,QAAQ,QAAQ,QAAQ,QAAW;AACrC,gBAAM,OAAgB,eAAAC,QAAQ,cAAc,GAAG;AAG/C,gBAAM,cAAc,KAAK,IAAI,KAAK,SAAS,GAAG,KAAK,SAAS,CAAC;AAG7D,gBAAM,eAAe,iBAAiB,IAAI;AAC1C,gBAAM,eAAe,iBAAiB,IAAI;AAC1C,gBAAM,kBAAkB,KAAK,IAAI,cAAc,YAAY,IAAI;AAE/D,gBAAM,gBAAgB,KAAK,QAAQ,iBAAiB,WAAW;AAC/D,gBAAM,gBAAgB,KAAK,QAAQ,iBAAiB,WAAW;AAE/D,cAAI,cAAc,UAAU,aAAa,IAAI,GAAG;AAC9C,uBAAW,sBAAAD,QAAW,cAAc,UAAU,MAAO,OAAO,IAAI;AAAA,UAClE;AAAA,QACF;AAGA,YAAI,QAAQ,QAAQ,QAAQ,QAAW;AACrC,gBAAM,OAAgB,eAAAC,QAAQ,cAAc,GAAG;AAG/C,gBAAM,cAAc,KAAK,IAAI,KAAK,SAAS,GAAG,KAAK,SAAS,CAAC;AAG7D,gBAAM,eAAe,iBAAiB,IAAI;AAC1C,gBAAM,eAAe,iBAAiB,IAAI;AAC1C,gBAAM,kBAAkB,KAAK,IAAI,cAAc,YAAY,IAAI;AAE/D,gBAAM,gBAAgB,KAAK,QAAQ,iBAAiB,WAAW;AAC/D,gBAAM,gBAAgB,KAAK,QAAQ,iBAAiB,WAAW;AAE/D,cAAI,cAAc,UAAU,aAAa,IAAI,GAAG;AAC9C,uBAAW,sBAAAD,QAAW,cAAc,UAAU,MAAO,OAAO,IAAI;AAAA,UAClE;AAAA,QACF;AAGA,eAAO;AAAA,MACT;AAAA,IAEF;AACE,YAAM,IAAI,gBAAAE,QAAoB,sBAAAF,QAAW,aAAa,oBAAoB,IAAI,+BAA+B;AAAA,EACjH;AACF;AAEA,IAAO,qBAAQ;","names":["Schema","doCommonTypeCheck","ValidationError","ErrorCodes","Decimal","InternetObjectError"]}