first commit

app_vue/node_modules/schema-utils/declarations/ValidationError.d.ts

@@ -0,0 +1,88 @@
+export default ValidationError;
+export type JSONSchema6 = import('json-schema').JSONSchema6;
+export type JSONSchema7 = import('json-schema').JSONSchema7;
+export type Schema =
+  | (import('json-schema').JSONSchema4 & import('./validate').Extend)
+  | (import('json-schema').JSONSchema6 & import('./validate').Extend)
+  | (import('json-schema').JSONSchema7 & import('./validate').Extend);
+export type ValidationErrorConfiguration = {
+  name?: string | undefined;
+  baseDataPath?: string | undefined;
+  postFormatter?: import('./validate').PostFormatter | undefined;
+};
+export type PostFormatter = (
+  formattedError: string,
+  error: import('ajv').ErrorObject & {
+    children?: import('ajv').ErrorObject[] | undefined;
+  }
+) => string;
+export type SchemaUtilErrorObject = import('ajv').ErrorObject & {
+  children?: import('ajv').ErrorObject[] | undefined;
+};
+export type SPECIFICITY = number;
+declare class ValidationError extends Error {
+  /**
+   * @param {Array<SchemaUtilErrorObject>} errors
+   * @param {Schema} schema
+   * @param {ValidationErrorConfiguration} configuration
+   */
+  constructor(
+    errors: Array<SchemaUtilErrorObject>,
+    schema: Schema,
+    configuration?: ValidationErrorConfiguration
+  );
+  /** @type {Array<SchemaUtilErrorObject>} */
+  errors: Array<SchemaUtilErrorObject>;
+  /** @type {Schema} */
+  schema: Schema;
+  /** @type {string} */
+  headerName: string;
+  /** @type {string} */
+  baseDataPath: string;
+  /** @type {PostFormatter | null} */
+  postFormatter: PostFormatter | null;
+  /**
+   * @param {string} path
+   * @returns {Schema}
+   */
+  getSchemaPart(path: string): Schema;
+  /**
+   * @param {Schema} schema
+   * @param {boolean} logic
+   * @param {Array<Object>} prevSchemas
+   * @returns {string}
+   */
+  formatSchema(
+    schema: Schema,
+    logic?: boolean,
+    prevSchemas?: Array<Object>
+  ): string;
+  /**
+   * @param {Schema=} schemaPart
+   * @param {(boolean | Array<string>)=} additionalPath
+   * @param {boolean=} needDot
+   * @param {boolean=} logic
+   * @returns {string}
+   */
+  getSchemaPartText(
+    schemaPart?: Schema | undefined,
+    additionalPath?: (boolean | Array<string>) | undefined,
+    needDot?: boolean | undefined,
+    logic?: boolean | undefined
+  ): string;
+  /**
+   * @param {Schema=} schemaPart
+   * @returns {string}
+   */
+  getSchemaPartDescription(schemaPart?: Schema | undefined): string;
+  /**
+   * @param {SchemaUtilErrorObject} error
+   * @returns {string}
+   */
+  formatValidationError(error: SchemaUtilErrorObject): string;
+  /**
+   * @param {Array<SchemaUtilErrorObject>} errors
+   * @returns {string}
+   */
+  formatValidationErrors(errors: Array<SchemaUtilErrorObject>): string;
+}

app_vue/node_modules/schema-utils/declarations/index.d.ts

@@ -0,0 +1,2 @@
+declare const _exports: typeof import('./validate').default;
+export = _exports;

app_vue/node_modules/schema-utils/declarations/keywords/absolutePath.d.ts

@@ -0,0 +1,12 @@
+export default addAbsolutePathKeyword;
+export type Ajv = import('ajv').Ajv;
+export type ValidateFunction = import('ajv').ValidateFunction;
+export type SchemaUtilErrorObject = import('ajv').ErrorObject & {
+  children?: import('ajv').ErrorObject[] | undefined;
+};
+/**
+ *
+ * @param {Ajv} ajv
+ * @returns {Ajv}
+ */
+declare function addAbsolutePathKeyword(ajv: Ajv): Ajv;

app_vue/node_modules/schema-utils/declarations/util/Range.d.ts

@@ -0,0 +1,82 @@
+export = Range;
+/**
+ * @typedef {[number, boolean]} RangeValue
+ */
+/**
+ * @callback RangeValueCallback
+ * @param {RangeValue} rangeValue
+ * @returns {boolean}
+ */
+declare class Range {
+  /**
+   * @param {"left" | "right"} side
+   * @param {boolean} exclusive
+   * @returns {">" | ">=" | "<" | "<="}
+   */
+  static getOperator(
+    side: 'left' | 'right',
+    exclusive: boolean
+  ): '>' | '>=' | '<' | '<=';
+  /**
+   * @param {number} value
+   * @param {boolean} logic is not logic applied
+   * @param {boolean} exclusive is range exclusive
+   * @returns {string}
+   */
+  static formatRight(value: number, logic: boolean, exclusive: boolean): string;
+  /**
+   * @param {number} value
+   * @param {boolean} logic is not logic applied
+   * @param {boolean} exclusive is range exclusive
+   * @returns {string}
+   */
+  static formatLeft(value: number, logic: boolean, exclusive: boolean): string;
+  /**
+   * @param {number} start left side value
+   * @param {number} end right side value
+   * @param {boolean} startExclusive is range exclusive from left side
+   * @param {boolean} endExclusive is range exclusive from right side
+   * @param {boolean} logic is not logic applied
+   * @returns {string}
+   */
+  static formatRange(
+    start: number,
+    end: number,
+    startExclusive: boolean,
+    endExclusive: boolean,
+    logic: boolean
+  ): string;
+  /**
+   * @param {Array<RangeValue>} values
+   * @param {boolean} logic is not logic applied
+   * @return {RangeValue} computed value and it's exclusive flag
+   */
+  static getRangeValue(
+    values: Array<[number, boolean]>,
+    logic: boolean
+  ): [number, boolean];
+  /** @type {Array<RangeValue>} */
+  _left: Array<[number, boolean]>;
+  /** @type {Array<RangeValue>} */
+  _right: Array<[number, boolean]>;
+  /**
+   * @param {number} value
+   * @param {boolean=} exclusive
+   */
+  left(value: number, exclusive?: boolean | undefined): void;
+  /**
+   * @param {number} value
+   * @param {boolean=} exclusive
+   */
+  right(value: number, exclusive?: boolean | undefined): void;
+  /**
+   * @param {boolean} logic is not logic applied
+   * @return {string} "smart" range string representation
+   */
+  format(logic?: boolean): string;
+}
+declare namespace Range {
+  export { RangeValue, RangeValueCallback };
+}
+type RangeValue = [number, boolean];
+type RangeValueCallback = (rangeValue: [number, boolean]) => boolean;

app_vue/node_modules/schema-utils/declarations/util/hints.d.ts

@@ -0,0 +1,6 @@
+export function stringHints(schema: Schema, logic: boolean): string[];
+export function numberHints(schema: Schema, logic: boolean): string[];
+export type Schema =
+  | (import('json-schema').JSONSchema4 & import('../validate').Extend)
+  | (import('json-schema').JSONSchema6 & import('../validate').Extend)
+  | (import('json-schema').JSONSchema7 & import('../validate').Extend);

app_vue/node_modules/schema-utils/declarations/validate.d.ts

@@ -0,0 +1,43 @@
+export default validate;
+export type JSONSchema4 = import('json-schema').JSONSchema4;
+export type JSONSchema6 = import('json-schema').JSONSchema6;
+export type JSONSchema7 = import('json-schema').JSONSchema7;
+export type ErrorObject = import('ajv').ErrorObject;
+export type Extend = {
+  formatMinimum?: number | undefined;
+  formatMaximum?: number | undefined;
+  formatExclusiveMinimum?: boolean | undefined;
+  formatExclusiveMaximum?: boolean | undefined;
+};
+export type Schema =
+  | (import('json-schema').JSONSchema4 & Extend)
+  | (import('json-schema').JSONSchema6 & Extend)
+  | (import('json-schema').JSONSchema7 & Extend);
+export type SchemaUtilErrorObject = import('ajv').ErrorObject & {
+  children?: import('ajv').ErrorObject[] | undefined;
+};
+export type PostFormatter = (
+  formattedError: string,
+  error: SchemaUtilErrorObject
+) => string;
+export type ValidationErrorConfiguration = {
+  name?: string | undefined;
+  baseDataPath?: string | undefined;
+  postFormatter?: PostFormatter | undefined;
+};
+/**
+ * @param {Schema} schema
+ * @param {Array<object> | object} options
+ * @param {ValidationErrorConfiguration=} configuration
+ * @returns {void}
+ */
+declare function validate(
+  schema: Schema,
+  options: Array<object> | object,
+  configuration?: ValidationErrorConfiguration | undefined
+): void;
+declare namespace validate {
+  export { ValidationError };
+  export { ValidationError as ValidateError };
+}
+import ValidationError from './ValidationError';