@yamato-daiwa/frontend-vue 0.2.0 → 0.3.0-alpha.2

package/Distributable/GUI_Components/Controls/ValidatableControlShell/ValidatableControlShell.vue.d.ts

@@ -0,0 +1,92 @@
+import { type ValidatableControlShellLocalization } from "@yamato-daiwa/frontend";
+import Badge from "../../Badge/Badge.vue";
+import { Vue as VueComponent } from "vue-facing-decorator";
+declare class ValidatableControlShell extends VueComponent {
+    static CSS_NAMESPACE: string;
+    protected readonly label?: string;
+    protected readonly guidance?: string;
+    protected get formattedGuidance(): string | null;
+    protected readonly required: boolean;
+    protected readonly mustDisplayAppropriateBadgeIfInputIsRequired: boolean;
+    protected readonly mustDisplayAppropriateBadgeIfInputIsOptional: boolean;
+    protected readonly mustAddInvisibleBadgeForHeightEqualizingWhenNoBadge: boolean;
+    protected readonly invalidInputHighlightingIfAnyValidationErrorsMessages: boolean;
+    protected readonly validValueHighlightingIfNoValidationErrorsMessages: boolean;
+    protected readonly coreElementHTML_ID?: string;
+    protected readonly labelElementHTML_ID?: string;
+    protected readonly mainSlotWrapperAdditionalCSS_Classes: ReadonlyArray<string>;
+    protected readonly validationErrorsMessages: ReadonlyArray<string>;
+    protected validationErrorsMessagesCopyForAnimating: ReadonlyArray<string>;
+    protected static readonly ERRORS_LIST_EXPANDING_ANIMATION_DURATION_PER_ONE_ERROR_MESSAGE__SECONDS: number;
+    protected get errorsListExpandingAnimationDuration__milliseconds(): number;
+    protected onValidationErrorsMessagesUpdated(): void;
+    protected get mustDisplayRequiredInputBadge(): boolean;
+    protected get mustDisplayOptionalInputBadge(): boolean;
+    protected get mustDisplayHeader(): boolean;
+    static readonly Themes: ValidatableControlShell.Themes;
+    static readonly selfAndChildrenComponentsThemesCorrespondence: {
+        badge: {
+            [ownThemeValue: string]: string;
+        };
+    };
+    protected readonly theme: string;
+    protected get badgeTheme(): string;
+    static defineThemes(ownAndChildrenThemesCorrespondenceDefinition: Readonly<{
+        [ownThemeKey: string]: Readonly<{
+            badge: string;
+        }>;
+    }>): typeof ValidatableControlShell;
+    static areThemesCSS_ClassesCommon: boolean;
+    static considerThemesAsCommon(): void;
+    protected readonly areThemesCSS_ClassesCommon: boolean;
+    static readonly GeometricVariations: ValidatableControlShell.GeometricVariations;
+    static readonly selfAndChildrenComponentsGeometricVariationsCorrespondence: {
+        badge: {
+            [ownGeometricVariationValue: string]: string;
+        };
+    };
+    protected readonly geometricVariation: string;
+    protected get badgeGeometricVariation(): string;
+    static defineGeometricVariations(ownAndChildrenGeometricVariationsAndCorrespondenceDefinition: Readonly<{
+        [ownGeometricVariationKey: string]: Readonly<{
+            badge: string;
+        }>;
+    }>): typeof ValidatableControlShell;
+    static readonly DecorativeVariations: ValidatableControlShell.DecorativeVariations;
+    static readonly selfAndChildrenComponentsDecorativeVariationsCorrespondence: {
+        requiredInputBadge: {
+            [ownDecorativeVariationValue: string]: string;
+        };
+        optionalInputBadge: {
+            [ownDecorativeVariationValue: string]: string;
+        };
+    };
+    protected readonly decorativeVariation: string;
+    protected get requiredInputBadgeDecorativeVariation(): string;
+    protected get optionalInputBadgeDecorativeVariation(): string;
+    static defineDecorativeVariations(ownAndChildrenDecorativeVariationsAndCorrespondenceDefinition: Readonly<{
+        [ownDecorativeVariationKey: string]: Readonly<{
+            requiredInputBadge: string;
+            optionalInputBadge: string;
+        }>;
+    }>): typeof ValidatableControlShell;
+    protected get rootElementModifierCSS_Classes(): ReadonlyArray<string>;
+    protected static readonly Badge: typeof Badge;
+    static localization: ValidatableControlShellLocalization;
+}
+declare namespace ValidatableControlShell {
+    type Themes = {
+        readonly regular: "REGULAR";
+        [themeName: string]: string;
+    };
+    type GeometricVariations = {
+        readonly regular: "REGULAR";
+        readonly small: "SMALL";
+        [geometricVariationName: string]: string;
+    };
+    type DecorativeVariations = {
+        readonly regular: "REGULAR";
+        [decorativeVariationName: string]: string;
+    };
+}
+export default ValidatableControlShell;

package/Distributable/GUI_Components/Controls/Validatables/InputtableControl.d.ts

@@ -0,0 +1,25 @@
+import { ValidatableControl } from "@yamato-daiwa/frontend";
+import { Vue as VueComponent } from "vue-facing-decorator";
+export default abstract class InputtableControl extends VueComponent {
+    protected readonly label?: string;
+    protected readonly accessibilityGuidance?: string;
+    protected readonly externalLabelHTML_ID?: string;
+    protected readonly guidance?: string;
+    protected readonly required: boolean;
+    protected readonly mustDisplayAppropriateBadgeIfInputIsRequired: boolean;
+    protected readonly mustDisplayAppropriateBadgeIfInputIsOptional: boolean;
+    protected readonly mustAddInvisibleBadgeForHeightEqualizingWhenNoBadge: boolean;
+    protected readonly disabled: boolean;
+    protected readonly readonly: boolean;
+    protected invalidInputHighlightingIfAnyValidationErrorsMessages: boolean;
+    protected validInputHighlightingIfAnyErrorsMessages: boolean;
+    highlightInvalidInput(): this;
+    getRootElementOffsetCoordinates(): ValidatableControl.RootElementOffsetCoordinates;
+    resetStateToInitial(): void;
+    protected beforeCreate(): void;
+    protected beforeUpdate(): void;
+    /** @descriptioin
+     * Validation with referencing of multiple properties is possible only via lifecycle hooks.
+     * This method is static because non-static methods are not accessible from the viewpoint of "vue-facing-decorator" */
+    protected static validateProperties(instance: InputtableControl): void;
+}

package/Distributable/GUI_Components/Controls/Validatables/InputtableControl.vue.d.ts

@@ -0,0 +1,25 @@
+import { type ValidatableControl } from "@yamato-daiwa/frontend";
+import { Vue as VueComponent } from "vue-facing-decorator";
+export default abstract class InputtableControl extends VueComponent {
+    protected readonly label?: string;
+    protected readonly accessibilityGuidance?: string;
+    protected readonly externalLabelHTML_ID?: string;
+    protected readonly guidance?: string;
+    protected readonly required: boolean;
+    protected readonly mustDisplayAppropriateBadgeIfInputIsRequired: boolean;
+    protected readonly mustDisplayAppropriateBadgeIfInputIsOptional: boolean;
+    protected readonly mustAddInvisibleBadgeForHeightEqualizingWhenNoBadge: boolean;
+    protected readonly disabled: boolean;
+    protected readonly readonly: boolean;
+    protected abstract invalidInputHighlightingIfAnyValidationErrorsMessages: boolean;
+    protected abstract validInputHighlightingIfNoErrorsMessages: boolean;
+    highlightInvalidInput(): this;
+    getRootElementOffsetCoordinates(): ValidatableControl.RootElementOffsetCoordinates;
+    resetStateToInitial(): void;
+    protected beforeCreate(): void;
+    protected beforeUpdate(): void;
+    /** @descriptioin
+     * Validation with referencing of multiple properties is possible only via lifecycle hooks.
+     * This method is static because non-static methods are not accessible from the viewpoint of "vue-facing-decorator" */
+    protected static validateProperties(instance: InputtableControl): void;
+}

package/Distributable/GUI_Components/Controls/Validatables/TextBox/TextBox.vue.d.ts

@@ -0,0 +1,124 @@
+import InputtableControl from "../InputtableControl.vue";
+import ValidatableControlShell from "../../ValidatableControlShell/ValidatableControlShell.vue";
+import type { InputtedValueValidation } from "@yamato-daiwa/frontend";
+import ValidatableControl from "../ValidatableControl";
+import { type ElementOfPseudoEnumeration } from "@yamato-daiwa/es-extensions";
+declare class TextBox extends InputtableControl implements ValidatableControl {
+    static CSS_NAMESPACE: string;
+    static HTML_Types: TextBox.HTML_Types;
+    static ValidityHighlightingActivationModes: TextBox.ValidityHighlightingActivationModes;
+    protected HTML_Type: ElementOfPseudoEnumeration<TextBox.HTML_Types>;
+    protected readonly placeholder?: string;
+    /** @see https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#autofill */
+    protected readonly autocomplete?: string;
+    protected readonly multiline: boolean;
+    protected readonly autoResizingForMultilineMode: boolean;
+    protected readonly minimalCharactersCount?: number;
+    protected readonly maximalCharactersCount?: number;
+    protected readonly minimalNumericValue?: number;
+    protected readonly maximalNumericValue?: number;
+    protected readonly valueMustBeTheNonNegativeIntegerOfRegularNotation: boolean;
+    protected readonly valueMustBeTheDigitsSequence: boolean;
+    protected readonly mustConvertEmptyValueToZero: boolean;
+    protected readonly mustConvertEmptyValueToNull: boolean;
+    focus(): this;
+    resetValidityHighlightingStateToInitial(): void;
+    protected rawInput: string;
+    protected invalidInputHighlightingIfAnyValidationErrorsMessages: boolean;
+    protected validInputHighlightingIfNoErrorsMessages: boolean;
+    protected validityHighlightingActivationMode: ElementOfPseudoEnumeration<typeof TextBox.ValidityHighlightingActivationModes>;
+    protected readonly validatablePayload: ValidatableControl.Payload<TextBox.SupportedValidatablePayloadValuesTypes, TextBox.SupportedValidatablePayloadValuesTypes, InputtedValueValidation>;
+    protected onKeyDown(event: KeyboardEvent): void;
+    protected onInput(rawValue: string): void;
+    protected onFocusOut(): void;
+    static readonly Themes: ValidatableControlShell.Themes;
+    static readonly selfAndChildrenComponentsThemesCorrespondence: {
+        validatableControlShell: {
+            [ownThemeValue: string]: string;
+        };
+    };
+    protected readonly theme: string;
+    protected get validatableControlShellTheme(): string;
+    static defineThemes(themesAndCorrespondenceDefinition: Readonly<{
+        [ownThemeKey: string]: Readonly<{
+            validatableControlShell: string;
+        }>;
+    }>): typeof ValidatableControlShell;
+    static areThemesCSS_ClassesCommon: boolean;
+    static considerThemesAsCommon(): void;
+    protected readonly areThemesCSS_ClassesCommon: boolean;
+    static readonly GeometricVariations: ValidatableControlShell.GeometricVariations;
+    static readonly selfAndChildrenComponentsGeometricVariationsCorrespondence: {
+        validatableControlShell: {
+            [ownGeometricVariationValue: string]: string;
+        };
+    };
+    protected readonly geometricVariation: string;
+    protected get validatableControlGeometricVariation(): string;
+    static defineGeometricVariations(ownAndChildrenGeometricVariationsAndCorrespondenceDefinition: Readonly<{
+        [ownGeometricVariationKey: string]: Readonly<{
+            badge: string;
+        }>;
+    }>): typeof TextBox;
+    static readonly DecorativeVariations: ValidatableControlShell.DecorativeVariations;
+    static readonly selfAndChildrenComponentsDecorativeVariationsCorrespondence: {
+        validatableControlShell: {
+            [ownDecorativeVariationValue: string]: string;
+        };
+    };
+    protected readonly decorativeVariation: string;
+    protected get validatableControlDecorativeVariation(): string;
+    static defineDecorativeVariations(decorativeVariationsNames: ReadonlyArray<string>): typeof ValidatableControlShell;
+    protected get rootElementModifierCSS_Classes(): ReadonlyArray<string>;
+    /** @descriptioin
+     * Validation with referencing of multiple properties is possible only via lifecycle hooks.
+     * This method is static because non-static methods are not accessible from the viewpoint of "vue-facing-decorator" */
+    protected static validateProperties(instance: TextBox): void;
+    protected static readonly INPUT_OR_TEXT_AREA_ELEMENT_VUE_REFERENCE_ID: string;
+    protected readonly INSTANCE_ID: string;
+    protected static counterForInstanceID_Generating: number;
+    static generateInstanceID(): string;
+    protected readonly inputOrTextareaElementHTML_ID?: string;
+    protected readonly labelElementHTML_ID?: string;
+    protected HTML_IDs: Readonly<{
+        inputOrTextarea: string;
+        label: string;
+    }>;
+    protected beforeCreate(): void;
+    protected created(): void;
+    protected beforeUpdate(): void;
+}
+declare namespace TextBox {
+    type HTML_Types = Readonly<{
+        regular: "text";
+        email: "email";
+        number: "number";
+        password: "password";
+        phoneNumber: "tel";
+        URI: "url";
+    }>;
+    type SupportedValidatablePayloadValuesTypes = string | number | null;
+    enum Events {
+        input = "update:modelValue",
+        blur = "BLUR"
+    }
+    type ValidityHighlightingActivationModes = Readonly<{
+        immediate: "IMMEDIATE";
+        onFirstInputtedCharacter: "ON_FIRST_INPUTTED_CHARACTER";
+        onFocusOut: "ON_FOCUS_OUT";
+    }>;
+    type Themes = {
+        readonly regular: "REGULAR";
+        [themeName: string]: string;
+    };
+    type GeometricVariations = {
+        readonly regular: "REGULAR";
+        readonly small: "SMALL";
+        [geometricVariationName: string]: string;
+    };
+    type DecorativeVariations = {
+        readonly regular: "REGULAR";
+        [decorativeVariationName: string]: string;
+    };
+}
+export default TextBox;

package/Distributable/GUI_Components/Controls/Validatables/ValidatableControl.d.ts

@@ -0,0 +1,54 @@
+import type { InputtedValueValidation, ValidatableControl as CorePackageValidatableControl } from "@yamato-daiwa/frontend";
+import type { ComponentPublicInstance as VueComponentPublicInstance } from "vue";
+import type { VueCons as VueClassComponent } from "vue-facing-decorator";
+type ValidatableControl = CorePackageValidatableControl;
+declare namespace ValidatableControl {
+    function isValidatableControl(potentialValidatableControl: unknown): potentialValidatableControl is ValidatableControl;
+    function getValidatableControlInstanceByVueReferenceID(compoundParameter: Readonly<{
+        parentVueComponentInstance: VueComponentPublicInstance | VueClassComponent;
+        vueReferenceID: string;
+    }>): ValidatableControl | null;
+    function getValidatableControlInstanceByVueReferenceID(compoundParameter: Readonly<{
+        parentVueComponentInstance: VueComponentPublicInstance | VueClassComponent;
+        vueReferenceID: string;
+        mustThrowErrorIsNotFoundOrNotValidatableControl: true;
+    }>): ValidatableControl;
+    class Payload<ValidValue, InvalidValue, Validation extends InputtedValueValidation> {
+        readonly ID: string;
+        readonly VUE_REFERENCE_ID: string;
+        readonly value: ValidValue | InvalidValue;
+        readonly validation: Validation;
+        readonly lastChangeSourceID?: string;
+        protected readonly validationResult: InputtedValueValidation.Result;
+        protected readonly asynchronousChecksStatus: InputtedValueValidation.AsynchronousChecks.Status | null;
+        static createInitialInstance<ValidValue, InvalidValue, Validation extends InputtedValueValidation>({ initialValue, validation, vueReferenceID }: Readonly<{
+            initialValue: ValidValue | InvalidValue;
+            validation: Validation;
+            vueReferenceID?: string;
+        }>): Payload<ValidValue, InvalidValue, Validation>;
+        protected constructor({ ID, vueReferenceID, value, validation, summarizingValidationErrorsMessages, lastChangeSourceID }: Readonly<{
+            /** @description Immutable for each instance. */
+            value: ValidValue | InvalidValue;
+            validation: Validation;
+            summarizingValidationErrorsMessages?: ReadonlyArray<string>;
+            lastChangeSourceID?: string;
+            /** @description Need to be kept when creating the new instance based on outdated one. */
+            ID?: string;
+            vueReferenceID?: string;
+        }>);
+        getComponentInstance(ownerComponent: VueComponentPublicInstance): ValidatableControl;
+        updateImmutably({ newValue }: {
+            newValue: ValidValue | InvalidValue;
+        }): Payload<ValidValue, InvalidValue, Validation>;
+        getExpectedToBeValidValue(): ValidValue;
+        get isEmpty(): boolean;
+        get isInvalid(): boolean;
+        get validationErrorsMessages(): Array<string>;
+        protected static counterForSelfID_Generating: number;
+        protected static generateSelfID(): string;
+        protected static counterForAssociatedComponentVueReferenceID_Generating: number;
+        protected static generateVueReferenceID_ForAssociatedComponent(): string;
+    }
+    function VModelChecker(rawVModel: unknown, valueChecker: (rawValue: unknown) => boolean): boolean;
+}
+export default ValidatableControl;

package/Distributable/GUI_Components/Controls/Validatables/ValidatableControlsGroup.d.ts

@@ -0,0 +1,38 @@
+import ValidatableControl from "./ValidatableControl";
+import type { InputtedValueValidation } from "@yamato-daiwa/frontend";
+import type { ComponentPublicInstance as VueComponentPublicInstance } from "vue";
+import type { Vue as VueClassComponent } from "vue-facing-decorator";
+import type { ArbitraryObject } from "@yamato-daiwa/es-extensions";
+export default class ValidatableControlsGroup<ValidData extends ArbitraryObject | Array<unknown>> {
+    readonly isInvalid: boolean;
+    readonly payload: ValidData | null;
+    readonly SCROLLING_CONTAINER_HTML_ID?: string;
+    protected readonly controlsPayload: ValidatableControlsGroup.GeneralizedControlsPayload;
+    static initialize<ValidData extends ArbitraryObject | Array<unknown>>(compoundParameter: Readonly<{
+        scrollingContainerHTML_ID?: string;
+    }>): ValidatableControlsGroup<ValidData>;
+    static hasInvalidInputs(controlsPayload: ValidatableControlsGroup.GeneralizedControlsPayload): boolean;
+    static pointOutValidationErrors({ controlsPayload, parentVueComponentInstance, scrollingContainerHTML_ID }: Readonly<{
+        controlsPayload: ValidatableControlsGroup.GeneralizedControlsPayload;
+        parentVueComponentInstance: VueComponentPublicInstance | InstanceType<typeof VueClassComponent>;
+        scrollingContainerHTML_ID?: string;
+    }>): void;
+    constructor(compoundParameter: Readonly<({
+        isInvalid: false;
+        payload: ValidData;
+    } | {
+        isInvalid: true;
+        payload: null;
+        controlsPayload: ValidatableControlsGroup.GeneralizedControlsPayload;
+    }) & {
+        scrollingContainerHTML_ID?: string;
+    }>);
+    getExpectedToBeValidPayload(): ValidData;
+    pointOutValidationErrors(parentVueComponentInstance: VueComponentPublicInstance): void;
+}
+declare namespace ValidatableControlsGroup {
+    type GeneralizedControlsPayload = Readonly<{
+        [controlKey: string]: ValidatableControl.Payload<unknown, unknown, InputtedValueValidation>;
+    }> | Array<ValidatableControl.Payload<unknown, unknown, InputtedValueValidation>>;
+}
+export {};

package/Distributable/GUI_Components/YDF_ComponentsCoordinator.d.ts

@@ -0,0 +1,103 @@
+export default abstract class YDF_ComponentsCoordinator {
+    static areThemesCSS_ClassesCommon: boolean;
+    static defineThemes<ComponentClass extends {
+        Themes: {
+            [themeName: string]: string;
+        };
+    }>(themesNames: ReadonlyArray<string>, TargetComponentClass: ComponentClass): ComponentClass;
+    static defineGeometricVariations<ComponentClass extends {
+        GeometricVariations: {
+            [decorativeVariationName: string]: string;
+        };
+    }>(geometricVariationsNames: ReadonlyArray<string>, TargetComponentClass: ComponentClass): ComponentClass;
+    static defineDecorativeVariations<ComponentClass extends {
+        DecorativeVariations: {
+            [decorativeVariationName: string]: string;
+        };
+    }>(decorativeVariationsNames: ReadonlyArray<string>, TargetComponentClass: ComponentClass): ComponentClass;
+    static defineThemesAndSetCorrespondenceWithOnesOfChildrenComponents<ComponentClass extends {
+        Themes: {
+            [themeKey: string]: string;
+        };
+        selfAndChildrenComponentsThemesCorrespondence: {
+            [childrenComponentKey: string]: {
+                [ownThemeValue: string]: string;
+            };
+        };
+    }>(ownAndChildrenThemesCorrespondenceDefinition: {
+        [ownThemeKey: string]: {
+            [childrenComponentKey: string]: string;
+        };
+    }, TargetComponentClass: ComponentClass): ComponentClass;
+    static defineGeometricVariationsAndSetCorrespondenceWithOnesOfChildrenComponents<ComponentClass extends {
+        GeometricVariations: {
+            [geometricVariationKey: string]: string;
+        };
+        selfAndChildrenComponentsGeometricVariationsCorrespondence: {
+            [childrenComponentKey: string]: {
+                [ownGeometricVariationValue: string]: string;
+            };
+        };
+    }>(geometricVariationsCorrespondenceDefinition: {
+        [ownGeometricVariationKey: string]: {
+            [childrenComponentKey: string]: string;
+        };
+    }, TargetComponentClass: ComponentClass): ComponentClass;
+    static defineDecorativeVariationsAndSetCorrespondenceWithOnesOfChildrenComponents<ComponentClass extends {
+        DecorativeVariations: {
+            [decorativeVariationKey: string]: string;
+        };
+        selfAndChildrenComponentsDecorativeVariationsCorrespondence: {
+            [childrenComponentKey: string]: {
+                [ownDecorativeVariationValue: string]: string;
+            };
+        };
+    }>(decorativeVariationsCorrespondenceDefinition: {
+        [ownDecorativeVariationKey: string]: {
+            [childrenComponentKey: string]: string;
+        };
+    }, TargetComponentClass: ComponentClass): ComponentClass;
+    static generateRootElementModifierCSS_Classes({ CSS_Namespace, activeTheme, allThemes, areThemesCSS_ClassesCommon, activeGeometricVariation, allGeometricVariations, activeGeometricModifiers, activeDecorativeVariation, allDecorativeVariations, activeDecorativeModifiers, other }: Readonly<{
+        CSS_Namespace: string;
+        activeTheme: string;
+        allThemes: Readonly<{
+            [themeKey: string]: string;
+        }>;
+        areThemesCSS_ClassesCommon: boolean;
+        activeGeometricVariation: string;
+        allGeometricVariations: Readonly<{
+            [geometricVariationKey: string]: string;
+        }>;
+        activeGeometricModifiers?: ReadonlyArray<string>;
+        activeDecorativeVariation?: string;
+        allDecorativeVariations?: Readonly<{
+            [decorativeVariationKey: string]: string;
+        }>;
+        activeDecorativeModifiers?: ReadonlyArray<string>;
+        other?: ReadonlyArray<string>;
+    }>): Array<string>;
+    static addThemeCSS_ClassToArrayIfMust({ themeValue, allThemes, areThemesCSS_ClassesCommon, CSS_Namespace }: Readonly<{
+        themeValue: string;
+        allThemes: Readonly<{
+            [themeKey: string]: string;
+        }>;
+        areThemesCSS_ClassesCommon: boolean;
+        CSS_Namespace: string;
+    }>): Array<string>;
+    static addGeometricVariationCSS_ClassToArrayIfMust({ geometricVariation, allGeometricVariations, CSS_Namespace }: Readonly<{
+        geometricVariation: string;
+        allGeometricVariations: Readonly<{
+            [geometricVariationKey: string]: string;
+        }>;
+        CSS_Namespace: string;
+    }>): Array<string>;
+    static addDecorativeVariationCSS_ClassToArrayIfMust({ decorativeVariation, allDecorativeVariations, CSS_Namespace }: Readonly<{
+        decorativeVariation: string;
+        allDecorativeVariations: Readonly<{
+            [decorativeVariationKey: string]: string;
+        }>;
+        CSS_Namespace: string;
+    }>): Array<string>;
+    static generateDemandedGeometricModifiersCSS_Classes(CSS_Namespace: string, demandedGeometricModifiersNames: ReadonlyArray<string>): Array<string>;
+    static generateDemandedDecorativeModifiersCSS_Classes(CSS_Namespace: string, demandedDecorativeModifiersNames: ReadonlyArray<string>): Array<string>;
+}

package/Distributable/GUI_Components/_Decorators/AccessibleFromTemplateAsNonReactive.d.ts

@@ -0,0 +1,2 @@
+declare const AccessibleFromTemplateAsNonReactive: PropertyDecorator;
+export default AccessibleFromTemplateAsNonReactive;

package/Distributable/GUI_Components/_Decorators/NonReactiveData.d.ts

@@ -0,0 +1 @@
+export default function NonReactiveData(initialValue: unknown): (_arguments: unknown, decoratorContext: (string | DecoratorContext)) => void;

package/Distributable/GUI_Components/_Decorators/NonReactiveVueData.d.ts

@@ -0,0 +1 @@
+export default function NonReactiveVueData(value: unknown): (_arguments: unknown, decoratorContext: string | DecoratorContext) => void;

package/Distributable/GUI_Components/_Decorators/OptionalButNotNullableVueProperty.d.ts

@@ -0,0 +1,2 @@
+declare const OptionalButNotNullableVueProperty: (_arguments: unknown, decoratorContext: (string | DecoratorContext)) => void;
+export default OptionalButNotNullableVueProperty;

package/Distributable/GUI_Components/_Decorators/preventNullForOptionalVueProperty.d.ts

@@ -0,0 +1,2 @@
+declare const preventNullForOptionalVueProperty: (_arguments: unknown, decoratorContext: string | DecoratorContext) => void;
+export default preventNullForOptionalVueProperty;

package/Distributable/GUI_Components/_Errors/ForbiddenNullValueOfOptionalVueProperty/ForbiddenNullValueOfOptionalVuePropertyError.d.ts

@@ -0,0 +1,19 @@
+declare class ForbiddenNullValueOfOptionalVuePropertyError extends Error {
+    static readonly NAME: string;
+    static localization: ForbiddenNullValueOfOptionalVuePropertyError.Localization;
+    constructor(constructorParameter: ForbiddenNullValueOfOptionalVuePropertyError.ConstructorParameter);
+}
+declare namespace ForbiddenNullValueOfOptionalVuePropertyError {
+    type ConstructorParameter = Localization.DescriptionTemplateParameters;
+    type Localization = Readonly<{
+        defaultTitle: string;
+        generateMessage: (templateParameters: Localization.DescriptionTemplateParameters) => string;
+    }>;
+    namespace Localization {
+        type DescriptionTemplateParameters = Readonly<{
+            targetComponentName?: string;
+            targetPropertyName: string;
+        }>;
+    }
+}
+export default ForbiddenNullValueOfOptionalVuePropertyError;

package/Distributable/GUI_Components/_Errors/ForbiddenNullValueOfOptionalVueProperty/ForbiddenNullValueOfOptionalVuePropertyErrorLocalization.english.d.ts

@@ -0,0 +1,3 @@
+import type ForbiddenNullValueOfOptionalVuePropertyError from "./ForbiddenNullValueOfOptionalVuePropertyError";
+declare const forbiddenVuePropertyNullValueErrorLocalization__english: ForbiddenNullValueOfOptionalVuePropertyError.Localization;
+export default forbiddenVuePropertyNullValueErrorLocalization__english;

package/Distributable/GUI_Components/_Errors/InvalidVuePropertiesCombination/InvalidVuePropertiesCombinationError.d.ts

@@ -0,0 +1,19 @@
+declare class InvalidVuePropertiesCombinationError extends Error {
+    static readonly NAME: string;
+    static localization: InvalidVuePropertiesCombinationError.Localization;
+    constructor(namedParameters: InvalidVuePropertiesCombinationError.ConstructorNamedParameters);
+}
+declare namespace InvalidVuePropertiesCombinationError {
+    type ConstructorNamedParameters = Localization.GenericDescriptionPartTemplateParameters;
+    type Localization = Readonly<{
+        defaultTitle: string;
+        generateMessage: (compoundParameter: Localization.GenericDescriptionPartTemplateParameters) => string;
+    }>;
+    namespace Localization {
+        type GenericDescriptionPartTemplateParameters = Readonly<{
+            vueComponentName: string;
+            messageSpecificPart?: string;
+        }>;
+    }
+}
+export default InvalidVuePropertiesCombinationError;

package/Distributable/GUI_Components/_Errors/InvalidVuePropertiesCombination/InvalidVuePropertiesCombinationErrorLocalization.english.d.ts

@@ -0,0 +1,3 @@
+import type InvalidVuePropertiesCombinationError from "./InvalidVuePropertiesCombinationError";
+declare const InvalidVuePropertiesCombinationErrorEnglishLocalization: InvalidVuePropertiesCombinationError.Localization;
+export default InvalidVuePropertiesCombinationErrorEnglishLocalization;

package/Distributable/GUI_Components/_Errors/InvalidVueProperty/InvalidVuePropertyError.d.ts

@@ -0,0 +1,20 @@
+declare class InvalidVuePropertyError extends Error {
+    static readonly NAME: string;
+    static localization: InvalidVuePropertyError.Localization;
+    constructor(compoundParameter: InvalidVuePropertyError.ConstructorParameter);
+}
+declare namespace InvalidVuePropertyError {
+    type ConstructorParameter = Localization.DescriptionTemplateVariables;
+    type Localization = Readonly<{
+        defaultTitle: string;
+        generateDescription: (templateVariables: Localization.DescriptionTemplateVariables) => string;
+    }>;
+    namespace Localization {
+        type DescriptionTemplateVariables = Readonly<{
+            componentName: string;
+            propertyName: string;
+            messageSpecificPart: string;
+        }>;
+    }
+}
+export default InvalidVuePropertyError;

package/Distributable/GUI_Components/_Errors/InvalidVueProperty/InvalidVuePropertyErrorLocalization.english.d.ts

@@ -0,0 +1,3 @@
+import type InvalidVuePropertyError from "./InvalidVuePropertyError";
+export declare const invalidVuePropertyErrorLocalization__english: InvalidVuePropertyError.Localization;
+export default invalidVuePropertyErrorLocalization__english;

package/Distributable/GUI_Components/_Errors/VueComponentImplementationHasNotBeenSet/VueComponentImplementationHasNotBeenSet.d.ts

@@ -0,0 +1,18 @@
+declare class VueComponentImplementationHasNotBeenSetError extends Error {
+    static readonly NAME: string;
+    static localization: VueComponentImplementationHasNotBeenSetError.Localization;
+    constructor(namedParameters: VueComponentImplementationHasNotBeenSetError.ConstructorNamedParameters);
+}
+declare namespace VueComponentImplementationHasNotBeenSetError {
+    type ConstructorNamedParameters = Localization.GenericDescriptionPartTemplateParameters;
+    type Localization = Readonly<{
+        defaultTitle: string;
+        generateMessage: (parametersObject: Localization.GenericDescriptionPartTemplateParameters) => string;
+    }>;
+    namespace Localization {
+        type GenericDescriptionPartTemplateParameters = Readonly<{
+            vueComponentName: string;
+        }>;
+    }
+}
+export default VueComponentImplementationHasNotBeenSetError;

package/Distributable/GUI_Components/_Errors/VueComponentImplementationHasNotBeenSet/VueComponentImplementationHasNotBeenSetErrorLocalization.english.d.ts

@@ -0,0 +1,3 @@
+import type VueComponentImplementationHasNotBeenSetError from "./VueComponentImplementationHasNotBeenSet";
+declare const VueComponentImplementationHasNotBeenSetErrorErrorEnglishLocalization: VueComponentImplementationHasNotBeenSetError.Localization;
+export default VueComponentImplementationHasNotBeenSetErrorErrorEnglishLocalization;

package/Distributable/GUI_Components/_Errors/VueComponentNotFound/VueComponentNotFoundError.d.ts

@@ -0,0 +1,22 @@
+declare class VueComponentNotFoundError extends Error {
+    static readonly NAME: string;
+    static localization: VueComponentNotFoundError.Localization;
+    name: string;
+    constructor(compoundParameter: VueComponentNotFoundError.ConstructorParameter);
+}
+declare namespace VueComponentNotFoundError {
+    type ConstructorParameter = Localization.DescriptionTemplateVariables | Readonly<{
+        customMessage: string;
+    }>;
+    type Localization = Readonly<{
+        defaultTitle: string;
+        generateDescription: (templateVariables: Localization.DescriptionTemplateVariables) => string;
+    }>;
+    namespace Localization {
+        type DescriptionTemplateVariables = Readonly<{
+            vueReferenceID: string;
+            messageSpecificPart?: string;
+        }>;
+    }
+}
+export default VueComponentNotFoundError;

package/Distributable/GUI_Components/_Errors/VueComponentNotFound/VueComponentNotFoundErrorLocalization.english.d.ts

@@ -0,0 +1,3 @@
+import type VueComponentNotFoundError from "./VueComponentNotFoundError";
+declare const vueComponentNotFoundErrorLocalization__english: VueComponentNotFoundError.Localization;
+export default vueComponentNotFoundErrorLocalization__english;

package/Distributable/GUI_Components/_Utils/VuePropertiesValidationMessagesGenerators/generateInvalidDecorativeVariationVuePropertyValidationMessage.d.ts

@@ -0,0 +1,4 @@
+/** @deprecated */
+export default function generateInvalidDecorativeVariationVuePropertyValidationMessage({ componentName }: Readonly<{
+    componentName: string;
+}>): string;

package/Distributable/GUI_Components/_Utils/VuePropertiesValidationMessagesGenerators/generateInvalidGeometricVariationVuePropertyValidationMessage.d.ts

@@ -0,0 +1,4 @@
+/** @deprecated */
+export default function generateInvalidGeometricVariationVuePropertyValidationMessage({ componentName }: Readonly<{
+    componentName: string;
+}>): string;

package/Distributable/GUI_Components/_Utils/VuePropertiesValidationMessagesGenerators/generateInvalidThemeVuePropertyValidationMessage.d.ts

@@ -0,0 +1,4 @@
+/** @deprecated */
+export default function generateInvalidThemeVuePropertyValidationMessage({ componentName }: Readonly<{
+    componentName: string;
+}>): string;

package/Distributable/GUI_Components/_Utils/VuePropertiesValidationMessagesGenerators/generateVuePropertyMustBeEitherEmptyStringOrUndefinedValidationMessage.d.ts

@@ -0,0 +1,2 @@
+/** @deprecated */
+export default function generateVuePropertyMustBeNonEmptyStringValidationMessage(): string;

package/Distributable/GUI_Components/_Utils/VuePropertiesValidationMessagesGenerators/generateVuePropertyMustBeNonEmptyStringOrUndefinedValidationMessage.d.ts

@@ -0,0 +1,2 @@
+/** @deprecated */
+export default function generateVuePropertyMustBeNonEmptyStringOrUndefinedValidationMessage(): string;