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

package/Distributable/Functions/Routing/extractVueRouteQueryParameterAsArray.d.ts

@@ -0,0 +1,6 @@
+import type { _RouteLocationBase as VueRouterLocation } from "vue-router";
+export default function extractVueRouteQueryParameterValueAsArrayOfStrings({ targetRoute, targetQueryParameterKey, arrayElementAdditionalValidator }: Readonly<{
+    targetRoute: VueRouterLocation;
+    targetQueryParameterKey: string;
+    arrayElementAdditionalValidator?: (rawValue: string) => boolean;
+}>): Array<string>;

package/Distributable/Functions/getElementByVueReference.d.ts

@@ -0,0 +1,23 @@
+import type { ComponentPublicInstance } from "vue";
+export default function getElementByVueReference(compoundParameter: Readonly<{
+    vueReferenceID: string;
+    parentVueComponent: ComponentPublicInstance;
+    mustExpectExactlyOneElement: true;
+}>): Element;
+export default function getElementByVueReference(compoundParameter: Readonly<{
+    vueReferenceID: string;
+    parentVueComponent: ComponentPublicInstance;
+    mustExpectExactlyOneElement: false;
+}>): Element | null;
+export default function getElementByVueReference<DOM_ElementSubtype extends Element>(compoundParameter: Readonly<{
+    vueReferenceID: string;
+    parentVueComponent: ComponentPublicInstance;
+    expectedDOM_ElementSubtype: new () => DOM_ElementSubtype;
+    mustExpectExactlyOneElement: true;
+}>): DOM_ElementSubtype;
+export default function getElementByVueReference<DOM_ElementSubtype extends Element>(compoundParameter: Readonly<{
+    vueReferenceID: string;
+    parentVueComponent: ComponentPublicInstance;
+    expectedDOM_ElementSubtype: new () => DOM_ElementSubtype;
+    mustExpectExactlyOneElement: false;
+}>): DOM_ElementSubtype | null;

package/Distributable/GUI_Components/AdmonitionBlock/AdmonitionBlock.vue.d.ts

@@ -0,0 +1,52 @@
+import type { AdmonitionBlockLocalization } from "@yamato-daiwa/frontend";
+import { Vue as VueComponent } from "vue-facing-decorator";
+declare class AdmonitionBlock extends VueComponent {
+    static CSS_NAMESPACE: string;
+    protected readonly title?: string;
+    protected readonly dismissible: boolean;
+    protected isDisplaying: boolean;
+    protected onClickDismissingButton(): void;
+    static readonly Themes: AdmonitionBlock.Themes;
+    protected readonly theme: string;
+    static defineThemes(themesNames: ReadonlyArray<string>): typeof AdmonitionBlock;
+    protected static areThemesCSS_ClassesCommon: boolean;
+    static considerThemesAsCommon(): void;
+    protected readonly areThemesCSS_ClassesCommon: boolean;
+    static readonly GeometricVariations: AdmonitionBlock.GeometricVariations;
+    protected readonly geometricVariation: string;
+    static defineGeometricVariations(geometricVariationsNames: ReadonlyArray<string>): typeof AdmonitionBlock;
+    static readonly DecorativeVariations: AdmonitionBlock.DecorativeVariations;
+    protected readonly decorativeVariation: string;
+    static defineDecorativeVariations(decorativeVariationsNames: ReadonlyArray<string>): typeof AdmonitionBlock;
+    protected readonly hasDefaultSVG_Icon: boolean;
+    protected get defaultSVG_IconComponentName(): string | null;
+    protected get rootElementModifierCSS_Classes(): Array<string>;
+    static localization: AdmonitionBlockLocalization;
+    protected readonly INSTANCE_ID: string;
+    protected static counterForInstanceID_Generating: number;
+    static generateInstanceID(): string;
+    protected TITLE_HTML_ID: string;
+    protected localization: AdmonitionBlockLocalization;
+    created(): void;
+}
+declare namespace AdmonitionBlock {
+    type Themes = {
+        readonly regular: "REGULAR";
+        [themeName: string]: string;
+    };
+    type GeometricVariations = {
+        readonly regular: "REGULAR";
+        readonly stickyNoteLike: "STICKY_NOTE_LIKE";
+        [variationName: string]: string;
+    };
+    type DecorativeVariations = {
+        readonly notice: "NOTICE";
+        readonly error: "ERROR";
+        readonly warning: "WARNING";
+        readonly success: "SUCCESS";
+        readonly guidance: "GUIDANCE";
+        readonly question: "QUESTION";
+        [variationName: string]: string;
+    };
+}
+export default AdmonitionBlock;

package/Distributable/GUI_Components/AdmonitionBlock/AdmonitionBlockLogic.vue.d.ts

@@ -0,0 +1,51 @@
+import type { AdmonitionBlockLocalization } from "@yamato-daiwa/frontend";
+import { Vue as VueComponent } from "vue-facing-decorator";
+declare class AdmonitionBlock extends VueComponent {
+    static CSS_NAMESPACE: string;
+    protected readonly title?: string;
+    protected readonly dismissible: boolean;
+    protected isDisplaying: boolean;
+    protected onClickDismissingButton(): void;
+    static readonly Themes: AdmonitionBlock.Themes;
+    protected readonly theme: string;
+    static defineThemes(themesNames: ReadonlyArray<string>): typeof AdmonitionBlock;
+    protected static areThemesCSS_ClassesCommon: boolean;
+    static considerThemesAsCommon(): void;
+    protected readonly areThemesCSS_ClassesCommon: boolean;
+    static readonly GeometricVariations: AdmonitionBlock.GeometricVariations;
+    protected readonly geometricVariation: string;
+    static defineGeometricVariations(geometricVariationsNames: ReadonlyArray<string>): typeof AdmonitionBlock;
+    static readonly DecorativeVariations: AdmonitionBlock.DecorativeVariations;
+    protected readonly decorativeVariation: string;
+    static defineDecorativeVariations(decorativeVariationsNames: ReadonlyArray<string>): typeof AdmonitionBlock;
+    protected readonly hasDefaultSVG_Icon: boolean;
+    protected get defaultSVG_IconComponentName(): string | null;
+    protected get rootElementModifierCSS_Classes(): Array<string>;
+    static localization: AdmonitionBlockLocalization;
+    protected readonly INSTANCE_ID: string;
+    protected static counterForInstanceID_Generating: number;
+    static generateInstanceID(): string;
+    protected TITLE_HTML_ID: string;
+    static applyStaticMembersToInheritorTransformedToOptionAPI(inheritedComponent: object): object;
+}
+declare namespace AdmonitionBlock {
+    type Themes = {
+        readonly regular: "REGULAR";
+        [themeName: string]: string;
+    };
+    type GeometricVariations = {
+        readonly regular: "REGULAR";
+        readonly stickyNoteLike: "STICKY_NOTE_LIKE";
+        [variationName: string]: string;
+    };
+    type DecorativeVariations = {
+        readonly notice: "NOTICE";
+        readonly error: "ERROR";
+        readonly warning: "WARNING";
+        readonly success: "SUCCESS";
+        readonly guidance: "GUIDANCE";
+        readonly question: "QUESTION";
+        [variationName: string]: string;
+    };
+}
+export default AdmonitionBlock;

package/Distributable/GUI_Components/Badge/Badge.vue.d.ts

@@ -0,0 +1,61 @@
+import { Vue as VueComponent } from "vue-facing-decorator";
+import { type ElementOfPseudoEnumeration } from "@yamato-daiwa/es-extensions";
+declare class Badge extends VueComponent {
+    static CSS_NAMESPACE: string;
+    protected readonly keyLabel?: string;
+    protected readonly valueLabel: string;
+    protected readonly rootElementTag: string;
+    static readonly Themes: Badge.Themes;
+    protected readonly theme: string;
+    static defineThemes(themesNames: ReadonlyArray<string>): typeof Badge;
+    static areThemesCSS_ClassesCommon: boolean;
+    static considerThemesAsCommon(): void;
+    protected readonly areThemesCSS_ClassesCommon: boolean;
+    static readonly GeometricVariations: Badge.GeometricVariations;
+    protected readonly geometricVariation: string;
+    static defineGeometricVariations(geometricVariationsNames: ReadonlyArray<string>): typeof Badge;
+    static readonly GeometricModifiers: Badge.GeometricModifiers;
+    protected readonly geometricModifiers: ReadonlyArray<ElementOfPseudoEnumeration<Badge.GeometricModifiers>>;
+    static readonly DecorativeVariations: Badge.DecorativeVariations;
+    protected readonly decorativeVariation: string;
+    static defineDecorativeVariations(decorativeVariationsNames: ReadonlyArray<string>): typeof Badge;
+    static readonly DecorativeModifiers: Badge.DecorativeModifiers;
+    protected readonly decorativeModifiers: ReadonlyArray<ElementOfPseudoEnumeration<Badge.DecorativeModifiers>>;
+    protected get rootElementModifierCSS_Classes(): ReadonlyArray<string>;
+}
+declare namespace Badge {
+    type Themes = {
+        readonly regular: "REGULAR";
+        [themeName: string]: string;
+    };
+    type GeometricVariations = {
+        readonly regular: "REGULAR";
+        [variationName: string]: string;
+    };
+    type GeometricModifiers = Readonly<{
+        pillShape: "PILL_SHAPE";
+        singleLine: "SINGLE_LINE";
+    }>;
+    type DecorativeVariations = {
+        readonly veryCatchyBright: "VERY_CATCHY_BRIGHT";
+        readonly catchyBright: "CATCHY_BRIGHT";
+        readonly modestlyCatchyBright: "MODESTLY_CATCHY_BRIGHT";
+        readonly neutralBright: "NEUTRAL_BRIGHT";
+        readonly modestlyCalmingBright: "MODESTLY_CALMING_BRIGHT";
+        readonly calmingBright: "CALMING_BRIGHT";
+        readonly achromaticBright: "ACHROMATIC_BRIGHT";
+        readonly veryCatchyPastel: "VERY_CATCHY_PASTEL";
+        readonly catchyPastel: "CATCHY_PASTEL";
+        readonly modestlyCatchyPastel: "MODESTLY_CATCHY_PASTEL";
+        readonly neutralPastel: "NEUTRAL_PASTEL";
+        readonly modestlyCalmingPastel: "MODESTLY_CALMING_PASTEL";
+        readonly calmingPastel: "CALMING_PASTEL";
+        readonly achromaticPastel: "ACHROMATIC_PASTEL";
+        [variationName: string]: string;
+    };
+    type DecorativeModifiers = Readonly<{
+        bordersDisguising: "BORDERS_DISGUISING";
+        noBackground: "NO_BACKGROUND";
+    }>;
+}
+export default Badge;

package/Distributable/GUI_Components/Badge/LoadingPlaceholder/Badge-LoadingPlaceholder.vue.d.ts

@@ -0,0 +1,10 @@
+import Badge from "../Badge.vue";
+import { Vue as VueComponent } from "vue-facing-decorator";
+import { type ElementOfPseudoEnumeration } from "@yamato-daiwa/es-extensions";
+export default class BadgeLoadingPlaceholder extends VueComponent {
+    protected readonly theme: string;
+    protected readonly areThemesCSS_ClassesCommon: boolean;
+    protected readonly geometricVariation: string;
+    protected readonly geometricModifiers: ReadonlyArray<ElementOfPseudoEnumeration<Badge.GeometricModifiers>>;
+    protected get rootElementModifierCSS_Classes(): ReadonlyArray<string>;
+}

package/Distributable/GUI_Components/ComponentsAuxiliaries.d.ts

@@ -0,0 +1,42 @@
+export default abstract class ComponentsAuxiliaries {
+    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 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/Controls/Buttons/Closing/ClosingButton.vue.d.ts

@@ -0,0 +1,54 @@
+import { Vue as VueComponent } from "vue-facing-decorator";
+import { type ElementOfPseudoEnumeration } from "@yamato-daiwa/es-extensions";
+declare class ClosingButton extends VueComponent {
+    static CSS_NAMESPACE: string;
+    static LabelLetterCases: ClosingButton.LabelLetterCases;
+    protected readonly customLabel?: string;
+    protected readonly noLabel: boolean;
+    protected readonly labelLetterCase: ElementOfPseudoEnumeration<ClosingButton.LabelLetterCases>;
+    protected readonly accessibilityGuidance?: string;
+    static readonly Themes: ClosingButton.Themes;
+    protected readonly theme: string;
+    static defineThemes(themesNames: ReadonlyArray<string>): typeof ClosingButton;
+    static areThemesCSS_ClassesCommon: boolean;
+    static considerThemesAsCommon(): void;
+    protected readonly areThemesCSS_ClassesCommon: boolean;
+    static readonly GeometricVariations: ClosingButton.GeometricVariations;
+    protected readonly geometricVariation: string;
+    static defineGeometricVariations(geometricVariationsNames: ReadonlyArray<string>): typeof ClosingButton;
+    static readonly GeometricModifiers: ClosingButton.GeometricModifiers;
+    protected readonly geometricModifiers: ReadonlyArray<ElementOfPseudoEnumeration<ClosingButton.GeometricModifiers>>;
+    static readonly DecorativeVariations: ClosingButton.DecorativeVariations;
+    protected readonly decorativeVariation: string;
+    static defineDecorativeVariations(decorativeVariationsNames: ReadonlyArray<string>): typeof ClosingButton;
+    static readonly DecorativeModifiers: ClosingButton.DecorativeModifiers;
+    protected readonly decorativeModifiers: ReadonlyArray<ElementOfPseudoEnumeration<ClosingButton.DecorativeModifiers>>;
+}
+declare namespace ClosingButton {
+    type LabelLetterCases = Readonly<{
+        uppercase: "UPPERCASE";
+        lowercase: "LOWERCASE";
+        capitalisation: "CAPITALISATION";
+    }>;
+    type Themes = {
+        readonly regular: "REGULAR";
+        [themeName: string]: string;
+    };
+    type GeometricVariations = {
+        readonly regular: "REGULAR";
+        [variationName: string]: string;
+    };
+    type GeometricModifiers = Readonly<{
+        noRoundings: "NO_ROUNDINGS";
+    }>;
+    type DecorativeVariations = {
+        readonly regular: "REGULAR";
+        [variationName: string]: string;
+    };
+    type DecorativeModifiers = Readonly<{
+        bordersDisguising: "BORDERS_DISGUISING";
+        noBackground: "NO_BACKGROUND";
+        noBackgroundInDefaultState: "NO_BACKGROUND_IN_DEFAULT_STATE";
+    }>;
+}
+export default ClosingButton;

package/Distributable/GUI_Components/Controls/Buttons/HamburgerMenu/HamburgerMenuButton-ForInheritance.vue.d.ts

@@ -0,0 +1,56 @@
+import { Vue as VueComponent } from "vue-facing-decorator";
+import { type ElementOfPseudoEnumeration } from "@yamato-daiwa/es-extensions";
+declare class HamburgerMenuButton extends VueComponent {
+    static CSS_NAMESPACE: string;
+    static LabelLetterCases: HamburgerMenuButton.LabelLetterCases;
+    protected readonly customLabel?: string;
+    protected readonly noLabel: boolean;
+    protected readonly labelLetterCase: ElementOfPseudoEnumeration<HamburgerMenuButton.LabelLetterCases>;
+    protected readonly alwaysEnglishLabel: boolean;
+    protected readonly accessibilityGuidance?: string;
+    static readonly Themes: HamburgerMenuButton.Themes;
+    protected readonly theme: string;
+    static defineThemes(themesNames: ReadonlyArray<string>): typeof HamburgerMenuButton;
+    static areThemesCSS_ClassesCommon: boolean;
+    static considerThemesAsCommon(): void;
+    protected readonly areThemesCSS_ClassesCommon: boolean;
+    static readonly GeometricVariations: HamburgerMenuButton.GeometricVariations;
+    protected readonly geometricVariation: string;
+    static defineGeometricVariations(geometricVariationsNames: ReadonlyArray<string>): typeof HamburgerMenuButton;
+    static readonly GeometricModifiers: HamburgerMenuButton.GeometricModifiers;
+    protected readonly geometricModifiers: ReadonlyArray<ElementOfPseudoEnumeration<HamburgerMenuButton.GeometricModifiers>>;
+    static readonly DecorativeVariations: HamburgerMenuButton.DecorativeVariations;
+    protected readonly decorativeVariation: string;
+    static defineDecorativeVariations(decorativeVariationsNames: ReadonlyArray<string>): typeof HamburgerMenuButton;
+    static readonly DecorativeModifiers: HamburgerMenuButton.DecorativeModifiers;
+    protected readonly decorativeModifiers: ReadonlyArray<ElementOfPseudoEnumeration<HamburgerMenuButton.DecorativeModifiers>>;
+    static applyStaticMembersToInheritorTransformedToOptionAPI(inheritedComponent: object): object;
+}
+declare namespace HamburgerMenuButton {
+    type LabelLetterCases = Readonly<{
+        uppercase: "UPPERCASE";
+        lowercase: "LOWERCASE";
+        capitalisation: "CAPITALISATION";
+    }>;
+    type Themes = {
+        readonly regular: "REGULAR";
+        [themeName: string]: string;
+    };
+    type GeometricVariations = {
+        readonly regular: "REGULAR";
+        [variationName: string]: string;
+    };
+    type GeometricModifiers = Readonly<{
+        noRoundings: "NO_ROUNDINGS";
+    }>;
+    type DecorativeVariations = {
+        readonly regular: "REGULAR";
+        [variationName: string]: string;
+    };
+    type DecorativeModifiers = Readonly<{
+        bordersDisguising: "BORDERS_DISGUISING";
+        noBackground: "NO_BACKGROUND";
+        noBackgroundInDefaultState: "NO_BACKGROUND_IN_DEFAULT_STATE";
+    }>;
+}
+export default HamburgerMenuButton;

package/Distributable/GUI_Components/Controls/Buttons/HamburgerMenu/HamburgerMenuButton.vue.d.ts

@@ -0,0 +1,55 @@
+import { Vue as VueComponent } from "vue-facing-decorator";
+import { type ElementOfPseudoEnumeration } from "@yamato-daiwa/es-extensions";
+declare class HamburgerMenuButton extends VueComponent {
+    static CSS_NAMESPACE: string;
+    static LabelLetterCases: HamburgerMenuButton.LabelLetterCases;
+    protected readonly customLabel?: string;
+    protected readonly noLabel: boolean;
+    protected readonly labelLetterCase: ElementOfPseudoEnumeration<HamburgerMenuButton.LabelLetterCases>;
+    protected readonly alwaysEnglishLabel: boolean;
+    protected readonly accessibilityGuidance?: string;
+    static readonly Themes: HamburgerMenuButton.Themes;
+    protected readonly theme: string;
+    static defineThemes(themesNames: ReadonlyArray<string>): typeof HamburgerMenuButton;
+    static areThemesCSS_ClassesCommon: boolean;
+    static considerThemesAsCommon(): void;
+    protected readonly areThemesCSS_ClassesCommon: boolean;
+    static readonly GeometricVariations: HamburgerMenuButton.GeometricVariations;
+    protected readonly geometricVariation: string;
+    static defineGeometricVariations(geometricVariationsNames: ReadonlyArray<string>): typeof HamburgerMenuButton;
+    static readonly GeometricModifiers: HamburgerMenuButton.GeometricModifiers;
+    protected readonly geometricModifiers: ReadonlyArray<ElementOfPseudoEnumeration<HamburgerMenuButton.GeometricModifiers>>;
+    static readonly DecorativeVariations: HamburgerMenuButton.DecorativeVariations;
+    protected readonly decorativeVariation: string;
+    static defineDecorativeVariations(decorativeVariationsNames: ReadonlyArray<string>): typeof HamburgerMenuButton;
+    static readonly DecorativeModifiers: HamburgerMenuButton.DecorativeModifiers;
+    protected readonly decorativeModifiers: ReadonlyArray<ElementOfPseudoEnumeration<HamburgerMenuButton.DecorativeModifiers>>;
+}
+declare namespace HamburgerMenuButton {
+    type LabelLetterCases = Readonly<{
+        uppercase: "UPPERCASE";
+        lowercase: "LOWERCASE";
+        capitalisation: "CAPITALISATION";
+    }>;
+    type Themes = {
+        readonly regular: "REGULAR";
+        [themeName: string]: string;
+    };
+    type GeometricVariations = {
+        readonly regular: "REGULAR";
+        [variationName: string]: string;
+    };
+    type GeometricModifiers = Readonly<{
+        noRoundings: "NO_ROUNDINGS";
+    }>;
+    type DecorativeVariations = {
+        readonly regular: "REGULAR";
+        [variationName: string]: string;
+    };
+    type DecorativeModifiers = Readonly<{
+        bordersDisguising: "BORDERS_DISGUISING";
+        noBackground: "NO_BACKGROUND";
+        noBackgroundInDefaultState: "NO_BACKGROUND_IN_DEFAULT_STATE";
+    }>;
+}
+export default HamburgerMenuButton;

package/Distributable/GUI_Components/Controls/Buttons/Plain/Button.vue.d.ts

@@ -0,0 +1,88 @@
+import { Vue as VueComponent } from "vue-facing-decorator";
+import type { RouteLocationRaw as VueRouterRawLocation } from "vue-router";
+import { type ElementOfPseudoEnumeration } from "@yamato-daiwa/es-extensions";
+declare class Button extends VueComponent {
+    static CSS_NAMESPACE: string;
+    static HTML_Types: Button.HTML_Types;
+    protected IS_NUXT: boolean;
+    private initializeNonReactiveClassFields;
+    protected readonly HTML_Type: ElementOfPseudoEnumeration<Button.HTML_Types>;
+    protected readonly label?: string | number;
+    protected readonly accessibilityGuidance?: string;
+    protected readonly route?: VueRouterRawLocation;
+    protected readonly externalURI?: string;
+    protected readonly mustOpenLinkInNewTab: boolean;
+    protected readonly mustRequestNotFollowLinkForCrawlingToSearchEngine: boolean;
+    protected readonly disabled: boolean;
+    protected readonly toggled: boolean;
+    static readonly Themes: Button.Themes;
+    protected readonly theme: string;
+    static defineThemes(themesNames: ReadonlyArray<string>): typeof Button;
+    static areThemesCSS_ClassesCommon: boolean;
+    static considerThemesAsCommon(): void;
+    private readonly areThemesCSS_ClassesCommon;
+    static readonly GeometricVariations: Button.GeometricVariations;
+    protected readonly geometricVariation: string;
+    static defineGeometricVariations(geometricVariationsNames: ReadonlyArray<string>): typeof Button;
+    static readonly GeometricModifiers: Button.GeometricModifiers;
+    protected readonly geometricModifiers: ReadonlyArray<ElementOfPseudoEnumeration<Button.GeometricModifiers>>;
+    static readonly DecorativeVariations: Button.DecorativeVariations;
+    protected readonly decorativeVariation: string;
+    static defineDecorativeVariations(decorativeVariationsNames: ReadonlyArray<string>): typeof Button;
+    static readonly DecorativeModifiers: Button.DecorativeModifiers;
+    protected readonly decorativeModifiers: ReadonlyArray<ElementOfPseudoEnumeration<Button.DecorativeModifiers>>;
+    protected created(): void;
+    protected beforeUpdate(): void;
+    protected get isButtonTheTagNameOfRootElement(): boolean;
+    protected get isInputTheTagNameOfRootElement(): boolean;
+    private get isRouterLinkTheRootElement();
+    private get isAnchorTheTagNameOfRootElement();
+    protected get typeAttributeValueOfButtonOrInputElement(): string | null;
+    protected get relAttributeValueOfAnchorElement(): string | null;
+    protected get rootElementModifierCSS_Classes(): ReadonlyArray<string>;
+    protected validateProperties(): void;
+}
+declare namespace Button {
+    type HTML_Types = Readonly<{
+        regular: "BUTTON";
+        submit: "SUBMIT";
+        inputButton: "INPUT_BUTTON";
+        inputSubmit: "INPUT_SUBMIT";
+        inputReset: "INPUT_RESET";
+    }>;
+    type Themes = {
+        readonly regular: "REGULAR";
+        [themeName: string]: string;
+    };
+    type GeometricVariations = {
+        readonly regular: "REGULAR";
+        readonly small: "SMALL";
+        readonly linkLike: "LINK_LIKE";
+        [variationName: string]: string;
+    };
+    type GeometricModifiers = Readonly<{
+        pillShape: "PILL_SHAPE";
+        squareShape: "SQUARE_SHAPE";
+        squareShapeUnlessOverflowed: "SQUARE_SHAPE_UNLESS_OVERFLOWED";
+        singleLine: "SINGLE_LINE";
+        noLeftBorderAndRoundings: "NO_LEFT_BORDER_AND_ROUNDINGS";
+        noRightBorderAndRoundings: "NO_RIGHT_BORDER_AND_ROUNDINGS";
+        noTopBorderAndRoundings: "NO_TOP_BORDER_AND_ROUNDINGS";
+        noBottomBorderAndRoundings: "NO_BOTTOM_BORDER_AND_ROUNDINGS";
+        noRoundings: "NO_ROUNDINGS";
+        horizontallyShrinkable: "HORIZONTALLY_SHRINKABLE";
+    }>;
+    type DecorativeVariations = {
+        readonly regular: "REGULAR";
+        readonly accented: "ACCENTED";
+        readonly danger: "DANGER";
+        readonly linkLike: "LINK_LIKE";
+        [variationName: string]: string;
+    };
+    type DecorativeModifiers = Readonly<{
+        bordersDisguising: "BORDERS_DISGUISING";
+        noBackground: "NO_BACKGROUND";
+        noBackgroundInDefaultState: "NO_BACKGROUND_IN_DEFAULT_STATE";
+    }>;
+}
+export default Button;

package/Distributable/GUI_Components/Controls/Buttons/Plain/LoadingPlaceholder/Button-LoadingPlaceholder.vue.d.ts

@@ -0,0 +1,10 @@
+import Button from "../Button.vue";
+import { Vue as VueComponent } from "vue-facing-decorator";
+import type { ElementOfPseudoEnumeration } from "@yamato-daiwa/es-extensions";
+export default class ButtonLoadingPlaceholder extends VueComponent {
+    protected readonly theme: string;
+    protected readonly areThemesCSS_ClassesCommon: boolean;
+    protected readonly geometricVariation: string;
+    protected readonly geometricModifiers: ReadonlyArray<ElementOfPseudoEnumeration<Button.GeometricModifiers>>;
+    protected get rootElementModifierCSS_Classes(): ReadonlyArray<string>;
+}

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

@@ -0,0 +1,17 @@
+import { Vue as VueComponent } from "vue-facing-decorator";
+export default 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 disabled: boolean;
+    protected invalidInputHighlightingIfAnyValidationErrorsMessages: boolean;
+    protected validInputHighlightingIfAnyErrorsMessages: boolean;
+    highlightInvalidInput(): this;
+    getRootElement(): Element;
+    resetStateToInitial(): void;
+    beforeCreate(): void;
+}

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

@@ -0,0 +1,51 @@
+import type { InputtedValueValidation } from "@yamato-daiwa/frontend";
+import type { ComponentPublicInstance as VueComponentPublicInstance } from "vue";
+interface ValidatableControl {
+    highlightInvalidInput: () => this;
+    getRootElementOffsetCoordinates: () => Element;
+    focus: () => this;
+    resetValidityHighlightingStateToInitial: () => ValidatableControl.RootElementOffsetCoordinates;
+}
+declare namespace ValidatableControl {
+    type RootElementOffsetCoordinates = Readonly<{
+        top: number;
+        left: number;
+    }>;
+    function isValidatableControl(potentialValidatableControl: unknown): potentialValidatableControl is ValidatableControl;
+    function getValidatableControlInstanceByVueReferenceID(compoundParameter: Readonly<{
+        parentVueComponentInstance: VueComponentPublicInstance;
+        vueReferenceID: string;
+    }>): ValidatableControl | null;
+    function getValidatableControlInstanceByVueReferenceID(compoundParameter: Readonly<{
+        parentVueComponentInstance: VueComponentPublicInstance;
+        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;
+        private readonly validationResult;
+        static createInitialInstance<ValidValue, InvalidValue, Validation extends InputtedValueValidation>(compoundParameter: Readonly<{
+            initialValue: ValidValue | InvalidValue;
+            validation: Validation;
+            vueReferenceID?: string;
+        }>): Payload<ValidValue, InvalidValue, Validation>;
+        private constructor();
+        getComponentInstance(ownerComponent: VueComponentPublicInstance): ValidatableControl;
+        get validationErrorsMessages(): Array<string>;
+        get isInvalid(): boolean;
+        getExpectedToBeValidValue(): ValidValue;
+        updateImmutably({ newValue }: {
+            newValue: ValidValue | InvalidValue;
+        }): Payload<ValidValue, InvalidValue, Validation>;
+        protected static counterForSelfID_Generating: number;
+        protected static generateSelfID(): string;
+        protected static counterForAssociatedComponentVueReferenceID_Generating: number;
+        protected static generateAssociatedComponentVueReferenceID(): string;
+    }
+    function VModelChecker(rawVModel: unknown, valueChecker: (rawValue: unknown) => boolean): boolean;
+}
+export default ValidatableControl;