@sitecore/sc-contenthub-webclient-sdk 0.9.7

package/dist/factories/entity-factory.js

@@ -0,0 +1,76 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityFactory = exports.EntityFactoryBase = void 0;
+const string_format_1 = __importDefault(require("string-format"));
+const entity_construction_args_1 = require("../contracts/base/entity-construction-args");
+const culture_load_option_1 = require("../contracts/querying/culture-load-option");
+const error_messages_1 = __importDefault(require("../error-messages"));
+const argument_error_1 = require("../errors/argument-error");
+const guard_1 = __importDefault(require("../guard"));
+const load_options_mapper_1 = require("../mappers/load-options-mapper");
+const property_factory_1 = require("./property-factory");
+class EntityFactoryBase {
+    constructor(client, relationFactory, cultureLoader, entityCreator) {
+        guard_1.default.notNullOrUndefined(client);
+        guard_1.default.notNullOrUndefined(relationFactory);
+        guard_1.default.notNullOrUndefined(cultureLoader);
+        guard_1.default.notNullOrUndefined(entityCreator);
+        this._client = client;
+        this._relationFactory = relationFactory;
+        this._cultureLoader = cultureLoader;
+        this._entityCreator = entityCreator;
+    }
+    createAsync(param, cultureLoadOption = culture_load_option_1.CultureLoadOption.Default) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let definition;
+            if (typeof param === "string") {
+                guard_1.default.stringNotNullOrEmpty(param);
+                definition = yield this.getEntityDefinitionAsync(param);
+            }
+            else {
+                guard_1.default.notNullOrUndefined(param);
+                definition = param;
+            }
+            const cultures = yield load_options_mapper_1.LoadOptionsMapper.mapCultureLoadOptionsAsync(cultureLoadOption, this._cultureLoader);
+            const properties = property_factory_1.PropertyFactory.createProperties(definition.getPropertyDefinitions(), cultures);
+            const relations = this._relationFactory.createRelations(definition.getRelationDefinitions());
+            const args = new entity_construction_args_1.EntityConstructionArgs(definition.name, {
+                cultures: cultures,
+                properties: properties,
+                relations: relations,
+            });
+            const entity = this._entityCreator.createTypedEntity(args);
+            entity.startTracking();
+            return entity;
+        });
+    }
+    getEntityDefinitionAsync(definitionName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const definition = yield this._client.entityDefinitions.getCachedAsync(definitionName);
+            if (definition == null) {
+                const errorMessage = string_format_1.default(error_messages_1.default.EntityFactory.DefinitionDoesNotExist, definitionName);
+                throw new argument_error_1.ArgumentError(errorMessage);
+            }
+            return definition;
+        });
+    }
+}
+exports.EntityFactoryBase = EntityFactoryBase;
+class EntityFactory extends EntityFactoryBase {
+    constructor(client, relationFactory, cultureLoader, entityCreator) {
+        super(client, relationFactory, cultureLoader, entityCreator);
+    }
+}
+exports.EntityFactory = EntityFactory;

package/dist/factories/option-list-factory.d.ts

@@ -0,0 +1,26 @@
+import { MapCultureTo } from "../base-types";
+import { IFlatOptionList } from "../contracts/base/option-lists/flat-option-list";
+import { IHierarchicalOptionList } from "../contracts/base/option-lists/hierarchical-option-list";
+/**
+ * A factory to create option lists.
+ */
+export interface IOptionListFactory {
+    /**
+     * Creates a new flat option list with the specified name.
+     * @param name - Name of the option list
+     * @param labels - Optional translations
+     * @returns A new flat option list instance.
+     */
+    createFlatOptionList(name: string, labels?: MapCultureTo<string>): IFlatOptionList;
+    /**
+     * Creates a new hierarchical option list with the specified name.
+     * @param name - Name of the option list
+     * @param labels - Optional translations
+     * @returns A new hierarchical option list instance.
+     */
+    createHierarchicalOptionList(name: string, labels?: MapCultureTo<string>): IHierarchicalOptionList;
+}
+export declare class OptionListFactory implements IOptionListFactory {
+    createFlatOptionList(name: string, labels?: MapCultureTo<string>): IFlatOptionList;
+    createHierarchicalOptionList(name: string, labels?: MapCultureTo<string>): IHierarchicalOptionList;
+}

package/dist/factories/option-list-factory.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OptionListFactory = void 0;
+const flat_option_list_1 = __importDefault(require("../contracts/base/option-lists/flat-option-list"));
+const hierarchical_option_list_1 = __importDefault(require("../contracts/base/option-lists/hierarchical-option-list"));
+const guard_1 = __importDefault(require("../guard"));
+class OptionListFactory {
+    createFlatOptionList(name, labels) {
+        guard_1.default.stringNotNullOrEmpty(name);
+        const optionList = new flat_option_list_1.default(name, labels);
+        return optionList;
+    }
+    createHierarchicalOptionList(name, labels) {
+        guard_1.default.stringNotNullOrEmpty(name);
+        const optionList = new hierarchical_option_list_1.default(name, labels);
+        return optionList;
+    }
+}
+exports.OptionListFactory = OptionListFactory;

package/dist/factories/property-factory.d.ts

@@ -0,0 +1,10 @@
+import { IPropertyDefinition } from "../contracts/base";
+import { ICultureInsensitiveProperty } from "../contracts/base/culture-insensitive-property";
+import { ICultureSensitiveProperty } from "../contracts/base/culture-sensitive-property";
+import { IProperty } from "../contracts/base/property";
+import CultureInfo from "../culture-info";
+export declare class PropertyFactory {
+    static createProperties(definitions: Array<IPropertyDefinition>, cultures?: Array<CultureInfo>): Array<IProperty>;
+    static createCultureSensitiveProperty(definition: IPropertyDefinition, cultures: Array<CultureInfo>): ICultureSensitiveProperty;
+    static createCultureInsensitiveProperty(definition: IPropertyDefinition): ICultureInsensitiveProperty;
+}

package/dist/factories/property-factory.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropertyFactory = void 0;
+const string_format_1 = __importDefault(require("string-format"));
+const base_1 = require("../contracts/base");
+const culture_insensitive_property_1 = require("../contracts/base/culture-insensitive-property");
+const culture_sensitive_property_1 = require("../contracts/base/culture-sensitive-property");
+const error_messages_1 = __importDefault(require("../error-messages"));
+const argument_error_1 = require("../errors/argument-error");
+const guard_1 = __importDefault(require("../guard"));
+class PropertyFactory {
+    static createProperties(definitions, cultures) {
+        if (definitions == null) {
+            return [];
+        }
+        const list = [];
+        for (const definition of definitions) {
+            if (definition.isMultiLanguage && cultures != undefined && cultures.length > 0) {
+                const property = this.createCultureSensitiveProperty(definition, cultures);
+                list.push(property);
+            }
+            else {
+                const property = this.createCultureInsensitiveProperty(definition);
+                list.push(property);
+            }
+        }
+        return list;
+    }
+    static createCultureSensitiveProperty(definition, cultures) {
+        guard_1.default.notNullOrUndefined(definition);
+        guard_1.default.notNullOrUndefined(cultures);
+        guard_1.default.arrayNotEmpty(cultures);
+        guard_1.default.arrayNoneNullOrInvariantCulture(cultures);
+        if (!definition.isMultiLanguage) {
+            const errorMessage = string_format_1.default(error_messages_1.default.PropertyFactory.MustBeCultureSensitive);
+            throw new argument_error_1.ArgumentError(errorMessage);
+        }
+        const property = new culture_sensitive_property_1.CultureSensitiveProperty(definition.name, new base_1.TypeInfo(definition.dataType, definition.isMultiValue), cultures);
+        return property;
+    }
+    static createCultureInsensitiveProperty(definition) {
+        guard_1.default.notNullOrUndefined(definition);
+        if (definition.isMultiLanguage) {
+            const errorMessage = string_format_1.default(error_messages_1.default.PropertyFactory.CannotBeCultureSensitive, definition.name);
+            throw new argument_error_1.ArgumentError(errorMessage);
+        }
+        const property = new culture_insensitive_property_1.CultureInsensitiveProperty(definition.name, new base_1.TypeInfo(definition.dataType, definition.isMultiValue));
+        return property;
+    }
+}
+exports.PropertyFactory = PropertyFactory;

package/dist/factories/relation-factory.d.ts

@@ -0,0 +1,55 @@
+import { IExtendedContentHubClient } from "../clients/extended-client";
+import { IRelation } from "../contracts/base/relation";
+import { IRelationDefinition } from "../contracts/base/relation-definition";
+import { IChildToManyParentsRelation } from "../contracts/base/relations/child-to-many-parents-relation";
+import { IChildToOneParentRelation } from "../contracts/base/relations/child-to-one-parent-relation";
+import { IParentToManyChildrenRelation } from "../contracts/base/relations/parent-to-many-children-relation";
+import { IParentToOneChildRelation } from "../contracts/base/relations/parent-to-one-child-relation";
+export interface IRelationFactory {
+    /**
+     * Creates a {@link IChildToManyParentsRelation}.
+     * @param definition - The relation definition
+     * @returns A new relation.
+     */
+    createChildToManyParentsRelation(definition: IRelationDefinition): IChildToManyParentsRelation;
+    /**
+     * Creates a {@link IChildToOneParentRelation}.
+     * @param definition - The relation definition
+     * @returns A new relation.
+     */
+    createChildToOneParentRelation(definition: IRelationDefinition): IChildToOneParentRelation;
+    /**
+     * Creates a {@link IParentToManyChildrenRelation}.
+     * @param definition - The relation definition
+     * @returns A new relation.
+     */
+    createParentToManyChildrenRelation(definition: IRelationDefinition): IParentToManyChildrenRelation;
+    /**
+     * Creates a {@link IParentToOneChildRelation}.
+     * @param definition - The relation definition
+     * @returns A new relation.
+     */
+    createParentToOneChildRelation(definition: IRelationDefinition): IParentToOneChildRelation;
+    /**
+     * Creates a {@link IRelation}.
+     * @param definition - The relation definition
+     * @returns A new relation.
+     */
+    createRelation(definition: IRelationDefinition): IRelation;
+    /**
+     * Creates a new {@link IRelation} collection.
+     * @param definition - The relation definition
+     * @returns A collection of relations.
+     */
+    createRelations(definitions: Array<IRelationDefinition>): Array<IRelation>;
+}
+export declare class RelationFactory implements IRelationFactory {
+    private readonly _client;
+    constructor(client: IExtendedContentHubClient);
+    createChildToManyParentsRelation(definition: IRelationDefinition): IChildToManyParentsRelation;
+    createChildToOneParentRelation(definition: IRelationDefinition): IChildToOneParentRelation;
+    createParentToManyChildrenRelation(definition: IRelationDefinition): IParentToManyChildrenRelation;
+    createParentToOneChildRelation(definition: IRelationDefinition): IParentToOneChildRelation;
+    createRelation(definition: IRelationDefinition): IRelation;
+    createRelations(definitions: Array<IRelationDefinition>): Array<IRelation>;
+}

package/dist/factories/relation-factory.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelationFactory = void 0;
+const relation_cardinality_1 = require("../contracts/base/relation-cardinality");
+const relation_role_1 = require("../contracts/base/relation-role");
+const child_to_many_parents_relation_1 = require("../contracts/base/relations/child-to-many-parents-relation");
+const child_to_one_parent_relation_1 = require("../contracts/base/relations/child-to-one-parent-relation");
+const parent_to_many_children_relation_1 = require("../contracts/base/relations/parent-to-many-children-relation");
+const parent_to_one_child_relation_1 = require("../contracts/base/relations/parent-to-one-child-relation");
+const guard_1 = __importDefault(require("../guard"));
+class RelationFactory {
+    constructor(client) {
+        this._client = client;
+    }
+    createChildToManyParentsRelation(definition) {
+        const relation = new child_to_many_parents_relation_1.ChildToManyParentsRelation(definition.name);
+        return relation;
+    }
+    createChildToOneParentRelation(definition) {
+        const relation = new child_to_one_parent_relation_1.ChildToOneParentRelation(definition.name);
+        return relation;
+    }
+    createParentToManyChildrenRelation(definition) {
+        const relation = new parent_to_many_children_relation_1.ParentToManyChildrenRelation(definition.name);
+        return relation;
+    }
+    createParentToOneChildRelation(definition) {
+        const relation = new parent_to_one_child_relation_1.ParentToOneChildRelation(definition.name);
+        return relation;
+    }
+    createRelation(definition) {
+        guard_1.default.notNullOrUndefined(definition);
+        let result = null;
+        if (definition.role === relation_role_1.RelationRole.Parent) {
+            if (definition.cardinality === relation_cardinality_1.RelationCardinality.ManyToMany ||
+                definition.cardinality === relation_cardinality_1.RelationCardinality.OneToMany) {
+                result = this.createParentToManyChildrenRelation(definition);
+            }
+            else if (definition.cardinality === relation_cardinality_1.RelationCardinality.OneToOne) {
+                result = this.createParentToOneChildRelation(definition);
+            }
+        }
+        else if (definition.role === relation_role_1.RelationRole.Child) {
+            if (definition.cardinality === relation_cardinality_1.RelationCardinality.ManyToMany) {
+                result = this.createChildToManyParentsRelation(definition);
+            }
+            else if (definition.cardinality === relation_cardinality_1.RelationCardinality.OneToOne ||
+                definition.cardinality === relation_cardinality_1.RelationCardinality.OneToMany) {
+                result = this.createChildToOneParentRelation(definition);
+            }
+        }
+        if (result === null) {
+            throw `Relation with name '${definition.name}', cardinality '${definition.cardinality}' and role '${definition.role}' not supported.`; //TODO
+        }
+        return result;
+    }
+    createRelations(definitions) {
+        if (!definitions || !definitions.length) {
+            return [];
+        }
+        const list = definitions.map(definition => {
+            return this.createRelation(definition);
+        });
+        return list;
+    }
+}
+exports.RelationFactory = RelationFactory;

package/dist/fileversion.d.ts

@@ -0,0 +1,78 @@
+import { Nullable } from "./base-types";
+/**
+ * Represents the file version of an assembly
+ */
+export declare class FileVersion {
+    major: number;
+    minor: number;
+    patch: number;
+    revision: number;
+    constructor(major: number, minor: number, patch?: number, revision?: number);
+    /**
+     * Parses a file version string (format: `<major>.<minor>.<patch>.<revision>`) to an instance.
+     *
+     * @remarks
+     * Throws an error when parsing fails.
+     *
+     * @param fileVersion - The file version string to parse
+     * @returns A file version instance.
+     */
+    static parse(fileVersion: string): FileVersion;
+    /**
+     * Tries to parse a file version string (see {@link FileVersion.parse}) and returns `null` or the specified default
+     * value when it fails.
+     *
+     * @param fileVersion - The file version string to parse
+     * @param defaultValue - The value to return when parsing fails
+     * @returns A file version instance or `null`.
+     */
+    static tryParse(fileVersion: string, defaultValue?: Nullable<FileVersion>): Nullable<FileVersion>;
+    /**
+     * Compares if the current instance is smaller than the specified version.
+     *
+     * @param otherVersion - The version to compare the current instance to
+     * @returns A boolean with the result.
+     */
+    smallerThan(otherVersion: FileVersion): boolean;
+    /**
+     * Compares if the current instance is smaller or equal than the specified version.
+     *
+     * @param otherVersion - The version to compare the current instance to
+     * @returns A boolean with the result.
+     */
+    smallerThanOrEqual(otherVersion: FileVersion): boolean;
+    /**
+     * Compares if the current instance is greater than the specified version.
+     *
+     * @param otherVersion - The version to compare the current instance to
+     * @returns A boolean with the result.
+     */
+    greaterThan(otherVersion: FileVersion): boolean;
+    /**
+     * Compares if the current instance is greater or equal than the specified version.
+     *
+     * @param otherVersion - The version to compare the current instance to
+     * @returns A boolean with the result.
+     */
+    greaterThanOrEqual(otherVersion: FileVersion): boolean;
+    /**
+     * Compares if the current instance equals (by values) the specified file.
+     *
+     * @param otherVersion - The version to compare the current instance to
+     * @returns A boolean with the result.
+     */
+    equals(otherVersion: FileVersion): boolean;
+    /**
+     * Compare the current instance with the specified file.
+     *
+     * @param otherVersion - The version to compare the current instance to
+     * @returns 0 when the versions are equal,.
+     *          1 when the current instance is greater,
+     *          -1 when the current instance is smaller
+     */
+    compareTo(otherVersion: FileVersion): 1 | 0 | -1;
+    /**
+     * Gets the file version string representation for this instance.
+     */
+    toString(): string;
+}

package/dist/fileversion.js

@@ -0,0 +1,144 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileVersion = void 0;
+const guard_1 = __importDefault(require("./guard"));
+/**
+ * Represents the file version of an assembly
+ */
+class FileVersion {
+    constructor(major, minor, patch = 0, revision = 0) {
+        this.major = major;
+        this.minor = minor;
+        this.patch = patch;
+        this.revision = revision;
+    }
+    /**
+     * Parses a file version string (format: `<major>.<minor>.<patch>.<revision>`) to an instance.
+     *
+     * @remarks
+     * Throws an error when parsing fails.
+     *
+     * @param fileVersion - The file version string to parse
+     * @returns A file version instance.
+     */
+    static parse(fileVersion) {
+        guard_1.default.stringNotNullOrEmpty(fileVersion);
+        try {
+            if (!/^(\d+\.){3}\d+$/.test(fileVersion)) {
+                throw 0;
+            }
+            const parts = fileVersion.split(".");
+            if (parts.length !== 4)
+                throw 0;
+            const major = parseInt(parts[0]);
+            const minor = parseInt(parts[1]);
+            const patch = parseInt(parts[2]);
+            const revision = parseInt(parts[3]);
+            if (isNaN(major + minor + patch + revision))
+                throw 0;
+            return new FileVersion(major, minor, patch, revision);
+        }
+        catch (ex) {
+            throw "Invalid version format. (Format: <major>.<minor>.<patch>.<revision>)";
+        }
+    }
+    /**
+     * Tries to parse a file version string (see {@link FileVersion.parse}) and returns `null` or the specified default
+     * value when it fails.
+     *
+     * @param fileVersion - The file version string to parse
+     * @param defaultValue - The value to return when parsing fails
+     * @returns A file version instance or `null`.
+     */
+    static tryParse(fileVersion, defaultValue = null) {
+        try {
+            return FileVersion.parse(fileVersion);
+        }
+        catch (ex) {
+            return defaultValue;
+        }
+    }
+    /**
+     * Compares if the current instance is smaller than the specified version.
+     *
+     * @param otherVersion - The version to compare the current instance to
+     * @returns A boolean with the result.
+     */
+    smallerThan(otherVersion) {
+        return this.compareTo(otherVersion) === -1;
+    }
+    /**
+     * Compares if the current instance is smaller or equal than the specified version.
+     *
+     * @param otherVersion - The version to compare the current instance to
+     * @returns A boolean with the result.
+     */
+    smallerThanOrEqual(otherVersion) {
+        return this.compareTo(otherVersion) !== 1;
+    }
+    /**
+     * Compares if the current instance is greater than the specified version.
+     *
+     * @param otherVersion - The version to compare the current instance to
+     * @returns A boolean with the result.
+     */
+    greaterThan(otherVersion) {
+        return this.compareTo(otherVersion) === 1;
+    }
+    /**
+     * Compares if the current instance is greater or equal than the specified version.
+     *
+     * @param otherVersion - The version to compare the current instance to
+     * @returns A boolean with the result.
+     */
+    greaterThanOrEqual(otherVersion) {
+        return this.compareTo(otherVersion) !== -1;
+    }
+    /**
+     * Compares if the current instance equals (by values) the specified file.
+     *
+     * @param otherVersion - The version to compare the current instance to
+     * @returns A boolean with the result.
+     */
+    equals(otherVersion) {
+        return this.compareTo(otherVersion) === 0;
+    }
+    /**
+     * Compare the current instance with the specified file.
+     *
+     * @param otherVersion - The version to compare the current instance to
+     * @returns 0 when the versions are equal,.
+     *          1 when the current instance is greater,
+     *          -1 when the current instance is smaller
+     */
+    compareTo(otherVersion) {
+        if (otherVersion == null) {
+            return 1;
+        }
+        else if (this.major !== otherVersion.major) {
+            return this.major < otherVersion.major ? -1 : 1;
+        }
+        else if (this.minor !== otherVersion.minor) {
+            return this.minor < otherVersion.minor ? -1 : 1;
+        }
+        else if (this.patch !== otherVersion.patch) {
+            return this.patch < otherVersion.patch ? -1 : 1;
+        }
+        else if (this.revision !== otherVersion.revision) {
+            return this.revision < otherVersion.revision ? -1 : 1;
+        }
+        return 0;
+    }
+    /**
+     * Gets the file version string representation for this instance.
+     */
+    toString() {
+        if (isNaN(this.major + this.minor + this.patch + this.revision))
+            return "";
+        return `${this.major}.${this.minor}.${this.patch}.${this.revision}`;
+    }
+}
+exports.FileVersion = FileVersion;

package/dist/guard.d.ts

@@ -0,0 +1,29 @@
+import CultureInfo from "./culture-info";
+export default class Guard {
+    static notNull(value: unknown, valueName?: string): void;
+    static notUndefined(value: unknown, valueName?: string): void;
+    static notNullOrUndefined(value: unknown, valueName?: string): void;
+    static parsableInteger(value: any, valueName?: string): void;
+    static parsableFloat(value: any, valueName?: string): void;
+    static isString: (value: string) => void;
+    static isInteger: (value: number) => void;
+    static arrayNotEmpty: (value: unknown[]) => void;
+    static arrayMaxOne: (value: unknown[]) => void;
+    static arrayNoneNullOrUndefined(value: Array<unknown>, valueName?: string, isOptional?: boolean): void;
+    static arrayNoneNullOrEmptyString(value: Array<unknown>, valueName?: string, isOptional?: boolean): void;
+    static arrayNoneNullOrInvariantCulture(value: Array<CultureInfo>, valueName?: string, isOptional?: boolean): void;
+    static isStringArray(value: Array<unknown>, valueName?: string, isOptional?: boolean): void;
+    static isIntegerArray(value: Array<unknown>, valueName?: string, isOptional?: boolean): void;
+    static isNumberArray(value: Array<unknown>, valueName?: string, isOptional?: boolean): void;
+    static stringNotNullOrEmpty: (value: string) => void;
+    static validId: (value: number) => void;
+    static validIdOrNull: (value: number | null) => void;
+    static validIds: (value: unknown[]) => void;
+    static notInvariantCulture: (culture: CultureInfo) => void;
+    static notNegative: (value: number) => void;
+    static greaterThan: (number: number, minValue: number) => void;
+    static greaterThanOrEqual: (number: number, minValue: number) => void;
+    static lessThan: (number: number, maxValue: number) => void;
+    static lessThanOrEqual: (number: number, maxValue: number) => void;
+    static isNumber: (value: number) => void;
+}