Feat: Multiplayer sessions added using CRUD database.

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

@@ -0,0 +1,74 @@
+export default ValidationError;
+export type JSONSchema6 = import("json-schema").JSONSchema6;
+export type JSONSchema7 = import("json-schema").JSONSchema7;
+export type Schema = import("./validate").Schema;
+export type ValidationErrorConfiguration =
+  import("./validate").ValidationErrorConfiguration;
+export type PostFormatter = import("./validate").PostFormatter;
+export type SchemaUtilErrorObject = import("./validate").SchemaUtilErrorObject;
+declare class ValidationError extends Error {
+  /**
+   * @param {Array<SchemaUtilErrorObject>} errors array of error objects
+   * @param {Schema} schema schema
+   * @param {ValidationErrorConfiguration} configuration 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 path
+   * @returns {Schema} schema
+   */
+  getSchemaPart(path: string): Schema;
+  /**
+   * @param {Schema} schema schema
+   * @param {boolean} logic logic
+   * @param {Array<object>} prevSchemas prev schemas
+   * @returns {string} formatted schema
+   */
+  formatSchema(
+    schema: Schema,
+    logic?: boolean,
+    prevSchemas?: Array<object>,
+  ): string;
+  /**
+   * @param {Schema=} schemaPart schema part
+   * @param {(boolean | Array<string>)=} additionalPath additional path
+   * @param {boolean=} needDot true when need dot
+   * @param {boolean=} logic logic
+   * @returns {string} schema part text
+   */
+  getSchemaPartText(
+    schemaPart?: Schema | undefined,
+    additionalPath?: (boolean | Array<string>) | undefined,
+    needDot?: boolean | undefined,
+    logic?: boolean | undefined,
+  ): string;
+  /**
+   * @param {Schema=} schemaPart schema part
+   * @returns {string} schema part description
+   */
+  getSchemaPartDescription(schemaPart?: Schema | undefined): string;
+  /**
+   * @param {SchemaUtilErrorObject} error error object
+   * @returns {string} formatted error object
+   */
+  formatValidationError(error: SchemaUtilErrorObject): string;
+  /**
+   * @param {Array<SchemaUtilErrorObject>} errors errors
+   * @returns {string} formatted errors
+   */
+  formatValidationErrors(errors: Array<SchemaUtilErrorObject>): string;
+}

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

@@ -0,0 +1,19 @@
+export type Schema = import("./validate").Schema;
+export type JSONSchema4 = import("./validate").JSONSchema4;
+export type JSONSchema6 = import("./validate").JSONSchema6;
+export type JSONSchema7 = import("./validate").JSONSchema7;
+export type ExtendedSchema = import("./validate").ExtendedSchema;
+export type ValidationErrorConfiguration =
+  import("./validate").ValidationErrorConfiguration;
+import { validate } from "./validate";
+import { ValidationError } from "./validate";
+import { enableValidation } from "./validate";
+import { disableValidation } from "./validate";
+import { needValidate } from "./validate";
+export {
+  validate,
+  ValidationError,
+  enableValidation,
+  disableValidation,
+  needValidate,
+};

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

@@ -0,0 +1,10 @@
+export default addAbsolutePathKeyword;
+export type Ajv = import("ajv").default;
+export type SchemaValidateFunction = import("ajv").SchemaValidateFunction;
+export type AnySchemaObject = import("ajv").AnySchemaObject;
+export type SchemaUtilErrorObject = import("../validate").SchemaUtilErrorObject;
+/**
+ * @param {Ajv} ajv ajv
+ * @returns {Ajv} configured ajv
+ */
+declare function addAbsolutePathKeyword(ajv: Ajv): Ajv;

node_modules/schema-utils/declarations/keywords/limit.d.ts

@@ -0,0 +1,14 @@
+export default addLimitKeyword;
+export type Ajv = import("ajv").default;
+export type Code = import("ajv").Code;
+export type Name = import("ajv").Name;
+export type KeywordErrorDefinition = import("ajv").KeywordErrorDefinition;
+/** @typedef {import("ajv").default} Ajv */
+/** @typedef {import("ajv").Code} Code */
+/** @typedef {import("ajv").Name} Name */
+/** @typedef {import("ajv").KeywordErrorDefinition} KeywordErrorDefinition */
+/**
+ * @param {Ajv} ajv ajv
+ * @returns {Ajv} ajv with limit keyword
+ */
+declare function addLimitKeyword(ajv: Ajv): Ajv;

node_modules/schema-utils/declarations/keywords/undefinedAsNull.d.ts

@@ -0,0 +1,14 @@
+export default addUndefinedAsNullKeyword;
+export type Ajv = import("ajv").default;
+export type SchemaValidateFunction = import("ajv").SchemaValidateFunction;
+export type AnySchemaObject = import("ajv").AnySchemaObject;
+export type ValidateFunction = import("ajv").ValidateFunction;
+/** @typedef {import("ajv").default} Ajv */
+/** @typedef {import("ajv").SchemaValidateFunction} SchemaValidateFunction */
+/** @typedef {import("ajv").AnySchemaObject} AnySchemaObject */
+/** @typedef {import("ajv").ValidateFunction} ValidateFunction */
+/**
+ * @param {Ajv} ajv ajv
+ * @returns {Ajv} configured ajv
+ */
+declare function addUndefinedAsNullKeyword(ajv: Ajv): Ajv;

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

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

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

@@ -0,0 +1,3 @@
+export function stringHints(schema: Schema, logic: boolean): string[];
+export function numberHints(schema: Schema, logic: boolean): string[];
+export type Schema = import("../validate").Schema;

node_modules/schema-utils/declarations/util/memorize.d.ts

@@ -0,0 +1,12 @@
+export default memoize;
+export type FunctionReturning<T> = () => T;
+/**
+ * @template T
+ * @typedef {() => T} FunctionReturning
+ */
+/**
+ * @template T
+ * @param {FunctionReturning<T>} fn memorized function
+ * @returns {FunctionReturning<T>} new function
+ */
+declare function memoize<T>(fn: FunctionReturning<T>): FunctionReturning<T>;

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

@@ -0,0 +1,77 @@
+export { default as ValidationError } from "./ValidationError";
+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 ExtendedSchema = {
+  /**
+   * format minimum
+   */
+  formatMinimum?: (string | number) | undefined;
+  /**
+   * format maximum
+   */
+  formatMaximum?: (string | number) | undefined;
+  /**
+   * format exclusive minimum
+   */
+  formatExclusiveMinimum?: (string | boolean) | undefined;
+  /**
+   * format exclusive maximum
+   */
+  formatExclusiveMaximum?: (string | boolean) | undefined;
+  /**
+   * link
+   */
+  link?: string | undefined;
+  /**
+   * undefined will be resolved as null
+   */
+  undefinedAsNull?: boolean | undefined;
+};
+export type Extend = ExtendedSchema;
+export type Schema = (JSONSchema4 | JSONSchema6 | JSONSchema7) & ExtendedSchema;
+export type SchemaUtilErrorObject = ErrorObject & {
+  children?: Array<ErrorObject>;
+};
+export type PostFormatter = (
+  formattedError: string,
+  error: SchemaUtilErrorObject,
+) => string;
+export type ValidationErrorConfiguration = {
+  /**
+   * name
+   */
+  name?: string | undefined;
+  /**
+   * base data path
+   */
+  baseDataPath?: string | undefined;
+  /**
+   * post formatter
+   */
+  postFormatter?: PostFormatter | undefined;
+};
+/**
+ * @param {Schema} schema schema
+ * @param {Array<object> | object} options options
+ * @param {ValidationErrorConfiguration=} configuration configuration
+ * @returns {void}
+ */
+export function validate(
+  schema: Schema,
+  options: Array<object> | object,
+  configuration?: ValidationErrorConfiguration | undefined,
+): void;
+/**
+ * @returns {void}
+ */
+export function enableValidation(): void;
+/**
+ * @returns {void}
+ */
+export function disableValidation(): void;
+/**
+ * @returns {boolean} true when need validate, otherwise false
+ */
+export function needValidate(): boolean;