@breadstone/mosaik-elements-angular 0.0.75 → 0.0.76

package/esm2022/Controls/Components/Selectors/Wizard/WizardComponent.mjs

@@ -0,0 +1,247 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+// ------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
+// </auto-generated>
+// ------------------------------------------------------------------------------
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, EventEmitter, inject, InjectionToken, Input, makeEnvironmentProviders, NgZone, Output } from '@angular/core';
+import { WizardElement } from '@breadstone/mosaik-elements-foundation';
+import { applyDefaults, ProxyCmp } from '../../../../Utils/Proxy';
+import * as i0 from "@angular/core";
+/**
+ * @public
+ *
+ * Injection token for the default properties of the WizardComponent.
+ * Use this token to provide default properties for the WizardComponent.
+ * The properties will be applied to the component when it is created.
+ * This is useful for setting default values for properties that are not set by the user.
+ */
+export const WIZARD_DEFAULT_PROPS = new InjectionToken('MOSAIK_WIZARD_DEFAULT_PROPS');
+/**
+ * @public
+ *
+ * @slot header - The header slot.
+ * @slot header-start - The sub header slot.
+ * @slot steps - The steps slot.
+ * @slot footer - The footer slot.
+ */
+let WizardComponent = class WizardComponent {
+    _element;
+    _zone;
+    _activeStepChanged;
+    _selectionChanged;
+    _itemsChanged;
+    _connected;
+    _disconnected;
+    _changed;
+    constructor() {
+        inject(ChangeDetectorRef).detach();
+        this._element = inject(ElementRef).nativeElement;
+        this._zone = inject(NgZone);
+        this._activeStepChanged = new EventEmitter();
+        this._element.on('activeStepChanged', (e) => this.onEmit(this._activeStepChanged, e));
+        this._selectionChanged = new EventEmitter();
+        this._element.on('selectionChanged', (e) => this.onEmit(this._selectionChanged, e));
+        this._itemsChanged = new EventEmitter();
+        this._element.on('itemsChanged', (e) => this.onEmit(this._itemsChanged, e));
+        this._connected = new EventEmitter();
+        this._element.on('connected', (e) => this.onEmit(this._connected, e));
+        this._disconnected = new EventEmitter();
+        this._element.on('disconnected', (e) => this.onEmit(this._disconnected, e));
+        this._changed = new EventEmitter();
+        this._element.on('changed', (e) => this.onEmit(this._changed, e));
+        applyDefaults(this._element, inject(WIZARD_DEFAULT_PROPS, { optional: true }) ?? {});
+    }
+    get name() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.name;
+    }
+    set name(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.name = value;
+        });
+    }
+    get activeIndex() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.activeIndex;
+    }
+    set activeIndex(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.activeIndex = value;
+        });
+    }
+    get themeName() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.themeName;
+    }
+    set themeName(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.themeName = value;
+        });
+    }
+    get fit() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.fit;
+    }
+    set fit(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.fit = value;
+        });
+    }
+    get disabled() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.disabled;
+    }
+    set disabled(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.disabled = value;
+        });
+    }
+    get items() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.items;
+    }
+    set items(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.items = value;
+        });
+    }
+    get selectedItem() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.selectedItem;
+    }
+    set selectedItem(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.selectedItem = value;
+        });
+    }
+    get dir() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.dir;
+    }
+    set dir(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.dir = value;
+        });
+    }
+    get lang() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.lang;
+    }
+    set lang(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.lang = value;
+        });
+    }
+    get activeStepChanged() {
+        return this._activeStepChanged;
+    }
+    get selectionChanged() {
+        return this._selectionChanged;
+    }
+    get itemsChanged() {
+        return this._itemsChanged;
+    }
+    get connected() {
+        return this._connected;
+    }
+    get disconnected() {
+        return this._disconnected;
+    }
+    get changed() {
+        return this._changed;
+    }
+    invoke(method, ...args) {
+        return this._element[method](...args);
+    }
+    onEmit(emitter, event) {
+        if (event instanceof CustomEvent) {
+            emitter.emit(event.detail);
+        }
+        else {
+            emitter.emit();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: WizardComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.0.6", type: WizardComponent, isStandalone: true, selector: "mosaik-wizard", inputs: { name: "name", activeIndex: "activeIndex", themeName: "themeName", fit: "fit", disabled: "disabled", items: "items", selectedItem: "selectedItem", dir: "dir", lang: "lang" }, outputs: { activeStepChanged: "activeStepChanged", selectionChanged: "selectionChanged", itemsChanged: "itemsChanged", connected: "connected", disconnected: "disconnected", changed: "changed" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+WizardComponent = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: () => customElements.define('mosaik-wizard', WizardElement),
+        inputs: ['name', 'activeIndex', 'themeName', 'fit', 'disabled', 'items', 'selectedItem', 'dir', 'lang'],
+        methods: ['assignToSlot', 'getSlotAssignments', 'getSlotAssignmentsOf', 'hasSlotContent', 'hasSlot', 'onSlotChanges', 'select', 'unselect', 'resetSelection', 'selectNext', 'selectPrevious', 'selectFirst', 'selectLast', 'adoptStyle', 'on', 'off', 'emit', 'requestUpdate']
+    }),
+    __metadata("design:paramtypes", [])
+], WizardComponent);
+export { WizardComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: WizardComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'mosaik-wizard',
+                    standalone: true,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['name', 'activeIndex', 'themeName', 'fit', 'disabled', 'items', 'selectedItem', 'dir', 'lang'],
+                    outputs: ['activeStepChanged', 'selectionChanged', 'itemsChanged', 'connected', 'disconnected', 'changed']
+                }]
+        }], ctorParameters: () => [], propDecorators: { name: [{
+                type: Input
+            }], activeIndex: [{
+                type: Input
+            }], themeName: [{
+                type: Input
+            }], fit: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], items: [{
+                type: Input
+            }], selectedItem: [{
+                type: Input
+            }], dir: [{
+                type: Input
+            }], lang: [{
+                type: Input
+            }], activeStepChanged: [{
+                type: Output
+            }], selectionChanged: [{
+                type: Output
+            }], itemsChanged: [{
+                type: Output
+            }], connected: [{
+                type: Output
+            }], disconnected: [{
+                type: Output
+            }], changed: [{
+                type: Output
+            }] } });
+/**
+ * @public
+ */
+export function provideWizard(config) {
+    return makeEnvironmentProviders([
+        {
+            provide: WIZARD_DEFAULT_PROPS,
+            useValue: config
+        }
+    ]);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"WizardComponent.js","sourceRoot":"","sources":["../../../../../../src/Controls/Components/Selectors/Wizard/WizardComponent.ts"],"names":[],"mappings":"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","sourcesContent":["// ------------------------------------------------------------------------------\n// <auto-generated>\n//     This code was generated by a tool.\n//     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.\n// </auto-generated>\n// ------------------------------------------------------------------------------\n\nimport { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, EnvironmentProviders, EventEmitter, inject, InjectionToken, Input, makeEnvironmentProviders, NgZone, Output } from '@angular/core';\nimport { WizardElement } from '@breadstone/mosaik-elements-foundation';\nimport { applyDefaults, ProxyCmp, MethodMap } from '../../../../Utils/Proxy';\n\n/**\n * @public\n *\n * Injection token for the default properties of the WizardComponent.\n * Use this token to provide default properties for the WizardComponent.\n * The properties will be applied to the component when it is created.\n * This is useful for setting default values for properties that are not set by the user.\n */\nexport const WIZARD_DEFAULT_PROPS = new InjectionToken<Partial<WizardElement.Props>>('MOSAIK_WIZARD_DEFAULT_PROPS');\n\n/**\n * @public\n *\n * @slot header - The header slot.\n * @slot header-start - The sub header slot.\n * @slot steps - The steps slot.\n * @slot footer - The footer slot.\n */\n\n@ProxyCmp({\n    defineCustomElementFn: () => customElements.define('mosaik-wizard', WizardElement),\n    inputs: ['name', 'activeIndex', 'themeName', 'fit', 'disabled', 'items', 'selectedItem', 'dir', 'lang'],\n    methods: ['assignToSlot', 'getSlotAssignments', 'getSlotAssignmentsOf', 'hasSlotContent', 'hasSlot', 'onSlotChanges', 'select', 'unselect', 'resetSelection', 'selectNext', 'selectPrevious', 'selectFirst', 'selectLast', 'adoptStyle', 'on', 'off', 'emit', 'requestUpdate']\n})\n@Component({\n    selector: 'mosaik-wizard',\n    standalone: true,\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    template: '<ng-content></ng-content>',\n    inputs: ['name', 'activeIndex', 'themeName', 'fit', 'disabled', 'items', 'selectedItem', 'dir', 'lang'],\n    outputs: ['activeStepChanged', 'selectionChanged', 'itemsChanged', 'connected', 'disconnected', 'changed']\n})\nexport class WizardComponent {\n    private readonly _element: WizardElement;\n    private readonly _zone: NgZone;\n\n    private readonly _activeStepChanged: EventEmitter<unknown>;\n    private readonly _selectionChanged: EventEmitter<unknown>;\n    private readonly _itemsChanged: EventEmitter<unknown>;\n    private readonly _connected: EventEmitter<unknown>;\n    private readonly _disconnected: EventEmitter<unknown>;\n    private readonly _changed: EventEmitter<unknown>;\n\n    public constructor() {\n        inject(ChangeDetectorRef).detach();\n\n        this._element = inject(ElementRef).nativeElement;\n        this._zone = inject(NgZone);\n\n        this._activeStepChanged = new EventEmitter<unknown>();\n        this._element.on('activeStepChanged', (e) => this.onEmit(this._activeStepChanged, e));\n        this._selectionChanged = new EventEmitter<unknown>();\n        this._element.on('selectionChanged', (e) => this.onEmit(this._selectionChanged, e));\n        this._itemsChanged = new EventEmitter<unknown>();\n        this._element.on('itemsChanged', (e) => this.onEmit(this._itemsChanged, e));\n        this._connected = new EventEmitter<unknown>();\n        this._element.on('connected', (e) => this.onEmit(this._connected, e));\n        this._disconnected = new EventEmitter<unknown>();\n        this._element.on('disconnected', (e) => this.onEmit(this._disconnected, e));\n        this._changed = new EventEmitter<unknown>();\n        this._element.on('changed', (e) => this.onEmit(this._changed, e));\n\n        applyDefaults(this._element, inject(WIZARD_DEFAULT_PROPS, { optional: true }) ?? {});\n    }\n\n    @Input()\n    public get name(): WizardElement['name'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.name;\n    }\n    public set name(value: WizardElement['name']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.name = value;\n        });\n    }\n\n    @Input()\n    public get activeIndex(): WizardElement['activeIndex'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.activeIndex;\n    }\n    public set activeIndex(value: WizardElement['activeIndex']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.activeIndex = value;\n        });\n    }\n\n    @Input()\n    public get themeName(): WizardElement['themeName'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.themeName;\n    }\n    public set themeName(value: WizardElement['themeName']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.themeName = value;\n        });\n    }\n\n    @Input()\n    public get fit(): WizardElement['fit'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.fit;\n    }\n    public set fit(value: WizardElement['fit']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.fit = value;\n        });\n    }\n\n    @Input()\n    public get disabled(): WizardElement['disabled'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.disabled;\n    }\n    public set disabled(value: WizardElement['disabled']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.disabled = value;\n        });\n    }\n\n    @Input()\n    public get items(): WizardElement['items'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.items;\n    }\n    public set items(value: WizardElement['items']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.items = value;\n        });\n    }\n\n    @Input()\n    public get selectedItem(): WizardElement['selectedItem'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.selectedItem;\n    }\n    public set selectedItem(value: WizardElement['selectedItem']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.selectedItem = value;\n        });\n    }\n\n    @Input()\n    public get dir(): WizardElement['dir'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.dir;\n    }\n    public set dir(value: WizardElement['dir']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.dir = value;\n        });\n    }\n\n    @Input()\n    public get lang(): WizardElement['lang'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.lang;\n    }\n    public set lang(value: WizardElement['lang']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.lang = value;\n        });\n    }\n\n    @Output()\n    public get activeStepChanged(): EventEmitter<unknown> {\n        return this._activeStepChanged;\n    }\n\n    @Output()\n    public get selectionChanged(): EventEmitter<unknown> {\n        return this._selectionChanged;\n    }\n\n    @Output()\n    public get itemsChanged(): EventEmitter<unknown> {\n        return this._itemsChanged;\n    }\n\n    @Output()\n    public get connected(): EventEmitter<unknown> {\n        return this._connected;\n    }\n\n    @Output()\n    public get disconnected(): EventEmitter<unknown> {\n        return this._disconnected;\n    }\n\n    @Output()\n    public get changed(): EventEmitter<unknown> {\n        return this._changed;\n    }\n\n    public invoke<TMethod extends WizardMethodNames>(method: TMethod, ...args: Parameters<WizardComponentMethods[TMethod]>): ReturnType<WizardComponentMethods[TMethod]> {\n        return (this._element as any)[method](...args);\n    }\n\n    private onEmit<T>(emitter: EventEmitter<T>, event: Event): void {\n        if (event instanceof CustomEvent) {\n            emitter.emit(event.detail);\n        } else {\n            emitter.emit();\n        }\n    }\n}\n\n/**\n * Declares the methods available on WizardComponent.\n */\nexport type WizardMethodNames = 'assignToSlot' | 'getSlotAssignments' | 'getSlotAssignmentsOf' | 'hasSlotContent' | 'hasSlot' | 'onSlotChanges' | 'select' | 'unselect' | 'resetSelection' | 'selectNext' | 'selectPrevious' | 'selectFirst' | 'selectLast' | 'adoptStyle' | 'on' | 'off' | 'emit' | 'requestUpdate';\n\n/**\n * Declares the methods interface for WizardComponent.\n */\nexport type WizardComponentMethods = MethodMap<WizardMethodNames>;\n\n/**\n * @public\n */\nexport function provideWizard(config: Partial<WizardElement.Props>): EnvironmentProviders {\n    return makeEnvironmentProviders([\n        {\n            provide: WIZARD_DEFAULT_PROPS,\n            useValue: config\n        }\n    ]);\n}\n"]}

package/esm2022/Controls/Components/Selectors/Wizard/WizardStepComponent.mjs

@@ -0,0 +1,285 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+// ------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
+// </auto-generated>
+// ------------------------------------------------------------------------------
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, EventEmitter, inject, InjectionToken, Input, makeEnvironmentProviders, NgZone, Output } from '@angular/core';
+import { WizardStepElement } from '@breadstone/mosaik-elements-foundation';
+import { applyDefaults, ProxyCmp } from '../../../../Utils/Proxy';
+import * as i0 from "@angular/core";
+/**
+ * @public
+ *
+ * Injection token for the default properties of the WizardStepComponent.
+ * Use this token to provide default properties for the WizardStepComponent.
+ * The properties will be applied to the component when it is created.
+ * This is useful for setting default values for properties that are not set by the user.
+ */
+export const WIZARD_STEP_DEFAULT_PROPS = new InjectionToken('MOSAIK_WIZARD_STEP_DEFAULT_PROPS');
+/**
+ * @public
+ *
+ * @slot  - The default slot.
+ * @slot footer - The footer slot.
+ */
+let WizardStepComponent = class WizardStepComponent {
+    _element;
+    _zone;
+    _selected;
+    _unselected;
+    _connected;
+    _disconnected;
+    _changed;
+    constructor() {
+        inject(ChangeDetectorRef).detach();
+        this._element = inject(ElementRef).nativeElement;
+        this._zone = inject(NgZone);
+        this._selected = new EventEmitter();
+        this._element.on('selected', (e) => this.onEmit(this._selected, e));
+        this._unselected = new EventEmitter();
+        this._element.on('unselected', (e) => this.onEmit(this._unselected, e));
+        this._connected = new EventEmitter();
+        this._element.on('connected', (e) => this.onEmit(this._connected, e));
+        this._disconnected = new EventEmitter();
+        this._element.on('disconnected', (e) => this.onEmit(this._disconnected, e));
+        this._changed = new EventEmitter();
+        this._element.on('changed', (e) => this.onEmit(this._changed, e));
+        applyDefaults(this._element, inject(WIZARD_STEP_DEFAULT_PROPS, { optional: true }) ?? {});
+    }
+    get header() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.header;
+    }
+    set header(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.header = value;
+        });
+    }
+    get subHeader() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.subHeader;
+    }
+    set subHeader(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.subHeader = value;
+        });
+    }
+    get isActive() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.isActive;
+    }
+    set isActive(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.isActive = value;
+        });
+    }
+    get themeName() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.themeName;
+    }
+    set themeName(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.themeName = value;
+        });
+    }
+    get enter() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.enter;
+    }
+    set enter(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.enter = value;
+        });
+    }
+    get exit() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.exit;
+    }
+    set exit(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.exit = value;
+        });
+    }
+    get inset() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.inset;
+    }
+    set inset(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.inset = value;
+        });
+    }
+    get isSelected() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.isSelected;
+    }
+    set isSelected(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.isSelected = value;
+        });
+    }
+    get index() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.index;
+    }
+    set index(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.index = value;
+        });
+    }
+    get displayText() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.displayText;
+    }
+    set displayText(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.displayText = value;
+        });
+    }
+    get value() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.value;
+    }
+    set value(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.value = value;
+        });
+    }
+    get dir() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.dir;
+    }
+    set dir(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.dir = value;
+        });
+    }
+    get lang() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.lang;
+    }
+    set lang(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.lang = value;
+        });
+    }
+    get selected() {
+        return this._selected;
+    }
+    get unselected() {
+        return this._unselected;
+    }
+    get connected() {
+        return this._connected;
+    }
+    get disconnected() {
+        return this._disconnected;
+    }
+    get changed() {
+        return this._changed;
+    }
+    invoke(method, ...args) {
+        return this._element[method](...args);
+    }
+    onEmit(emitter, event) {
+        if (event instanceof CustomEvent) {
+            emitter.emit(event.detail);
+        }
+        else {
+            emitter.emit();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: WizardStepComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.0.6", type: WizardStepComponent, isStandalone: true, selector: "mosaik-wizard-step", inputs: { header: "header", subHeader: "subHeader", isActive: "isActive", themeName: "themeName", enter: "enter", exit: "exit", inset: "inset", isSelected: "isSelected", index: "index", displayText: "displayText", value: "value", dir: "dir", lang: "lang" }, outputs: { selected: "selected", unselected: "unselected", connected: "connected", disconnected: "disconnected", changed: "changed" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+WizardStepComponent = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: () => customElements.define('mosaik-wizard-step', WizardStepElement),
+        inputs: ['header', 'subHeader', 'isActive', 'themeName', 'enter', 'exit', 'inset', 'isSelected', 'index', 'displayText', 'value', 'dir', 'lang'],
+        methods: ['play', 'onEnterAnimation', 'onExitAnimation', 'select', 'unselect', 'adoptStyle', 'on', 'off', 'emit', 'requestUpdate']
+    }),
+    __metadata("design:paramtypes", [])
+], WizardStepComponent);
+export { WizardStepComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: WizardStepComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'mosaik-wizard-step',
+                    standalone: true,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['header', 'subHeader', 'isActive', 'themeName', 'enter', 'exit', 'inset', 'isSelected', 'index', 'displayText', 'value', 'dir', 'lang'],
+                    outputs: ['selected', 'unselected', 'connected', 'disconnected', 'changed']
+                }]
+        }], ctorParameters: () => [], propDecorators: { header: [{
+                type: Input
+            }], subHeader: [{
+                type: Input
+            }], isActive: [{
+                type: Input
+            }], themeName: [{
+                type: Input
+            }], enter: [{
+                type: Input
+            }], exit: [{
+                type: Input
+            }], inset: [{
+                type: Input
+            }], isSelected: [{
+                type: Input
+            }], index: [{
+                type: Input
+            }], displayText: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], dir: [{
+                type: Input
+            }], lang: [{
+                type: Input
+            }], selected: [{
+                type: Output
+            }], unselected: [{
+                type: Output
+            }], connected: [{
+                type: Output
+            }], disconnected: [{
+                type: Output
+            }], changed: [{
+                type: Output
+            }] } });
+/**
+ * @public
+ */
+export function provideWizardStep(config) {
+    return makeEnvironmentProviders([
+        {
+            provide: WIZARD_STEP_DEFAULT_PROPS,
+            useValue: config
+        }
+    ]);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"WizardStepComponent.js","sourceRoot":"","sources":["../../../../../../src/Controls/Components/Selectors/Wizard/WizardStepComponent.ts"],"names":[],"mappings":"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","sourcesContent":["// ------------------------------------------------------------------------------\n// <auto-generated>\n//     This code was generated by a tool.\n//     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.\n// </auto-generated>\n// ------------------------------------------------------------------------------\n\nimport { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, EnvironmentProviders, EventEmitter, inject, InjectionToken, Input, makeEnvironmentProviders, NgZone, Output } from '@angular/core';\nimport { WizardStepElement } from '@breadstone/mosaik-elements-foundation';\nimport { applyDefaults, ProxyCmp, MethodMap } from '../../../../Utils/Proxy';\n\n/**\n * @public\n *\n * Injection token for the default properties of the WizardStepComponent.\n * Use this token to provide default properties for the WizardStepComponent.\n * The properties will be applied to the component when it is created.\n * This is useful for setting default values for properties that are not set by the user.\n */\nexport const WIZARD_STEP_DEFAULT_PROPS = new InjectionToken<Partial<WizardStepElement.Props>>('MOSAIK_WIZARD_STEP_DEFAULT_PROPS');\n\n/**\n * @public\n *\n * @slot  - The default slot.\n * @slot footer - The footer slot.\n */\n\n@ProxyCmp({\n    defineCustomElementFn: () => customElements.define('mosaik-wizard-step', WizardStepElement),\n    inputs: ['header', 'subHeader', 'isActive', 'themeName', 'enter', 'exit', 'inset', 'isSelected', 'index', 'displayText', 'value', 'dir', 'lang'],\n    methods: ['play', 'onEnterAnimation', 'onExitAnimation', 'select', 'unselect', 'adoptStyle', 'on', 'off', 'emit', 'requestUpdate']\n})\n@Component({\n    selector: 'mosaik-wizard-step',\n    standalone: true,\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    template: '<ng-content></ng-content>',\n    inputs: ['header', 'subHeader', 'isActive', 'themeName', 'enter', 'exit', 'inset', 'isSelected', 'index', 'displayText', 'value', 'dir', 'lang'],\n    outputs: ['selected', 'unselected', 'connected', 'disconnected', 'changed']\n})\nexport class WizardStepComponent {\n    private readonly _element: WizardStepElement;\n    private readonly _zone: NgZone;\n\n    private readonly _selected: EventEmitter<unknown>;\n    private readonly _unselected: EventEmitter<unknown>;\n    private readonly _connected: EventEmitter<unknown>;\n    private readonly _disconnected: EventEmitter<unknown>;\n    private readonly _changed: EventEmitter<unknown>;\n\n    public constructor() {\n        inject(ChangeDetectorRef).detach();\n\n        this._element = inject(ElementRef).nativeElement;\n        this._zone = inject(NgZone);\n\n        this._selected = new EventEmitter<unknown>();\n        this._element.on('selected', (e) => this.onEmit(this._selected, e));\n        this._unselected = new EventEmitter<unknown>();\n        this._element.on('unselected', (e) => this.onEmit(this._unselected, e));\n        this._connected = new EventEmitter<unknown>();\n        this._element.on('connected', (e) => this.onEmit(this._connected, e));\n        this._disconnected = new EventEmitter<unknown>();\n        this._element.on('disconnected', (e) => this.onEmit(this._disconnected, e));\n        this._changed = new EventEmitter<unknown>();\n        this._element.on('changed', (e) => this.onEmit(this._changed, e));\n\n        applyDefaults(this._element, inject(WIZARD_STEP_DEFAULT_PROPS, { optional: true }) ?? {});\n    }\n\n    @Input()\n    public get header(): WizardStepElement['header'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.header;\n    }\n    public set header(value: WizardStepElement['header']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.header = value;\n        });\n    }\n\n    @Input()\n    public get subHeader(): WizardStepElement['subHeader'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.subHeader;\n    }\n    public set subHeader(value: WizardStepElement['subHeader']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.subHeader = value;\n        });\n    }\n\n    @Input()\n    public get isActive(): WizardStepElement['isActive'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.isActive;\n    }\n    public set isActive(value: WizardStepElement['isActive']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.isActive = value;\n        });\n    }\n\n    @Input()\n    public get themeName(): WizardStepElement['themeName'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.themeName;\n    }\n    public set themeName(value: WizardStepElement['themeName']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.themeName = value;\n        });\n    }\n\n    @Input()\n    public get enter(): WizardStepElement['enter'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.enter;\n    }\n    public set enter(value: WizardStepElement['enter']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.enter = value;\n        });\n    }\n\n    @Input()\n    public get exit(): WizardStepElement['exit'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.exit;\n    }\n    public set exit(value: WizardStepElement['exit']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.exit = value;\n        });\n    }\n\n    @Input()\n    public get inset(): WizardStepElement['inset'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.inset;\n    }\n    public set inset(value: WizardStepElement['inset']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.inset = value;\n        });\n    }\n\n    @Input()\n    public get isSelected(): WizardStepElement['isSelected'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.isSelected;\n    }\n    public set isSelected(value: WizardStepElement['isSelected']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.isSelected = value;\n        });\n    }\n\n    @Input()\n    public get index(): WizardStepElement['index'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.index;\n    }\n    public set index(value: WizardStepElement['index']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.index = value;\n        });\n    }\n\n    @Input()\n    public get displayText(): WizardStepElement['displayText'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.displayText;\n    }\n    public set displayText(value: WizardStepElement['displayText']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.displayText = value;\n        });\n    }\n\n    @Input()\n    public get value(): WizardStepElement['value'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.value;\n    }\n    public set value(value: WizardStepElement['value']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.value = value;\n        });\n    }\n\n    @Input()\n    public get dir(): WizardStepElement['dir'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.dir;\n    }\n    public set dir(value: WizardStepElement['dir']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.dir = value;\n        });\n    }\n\n    @Input()\n    public get lang(): WizardStepElement['lang'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.lang;\n    }\n    public set lang(value: WizardStepElement['lang']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.lang = value;\n        });\n    }\n\n    @Output()\n    public get selected(): EventEmitter<unknown> {\n        return this._selected;\n    }\n\n    @Output()\n    public get unselected(): EventEmitter<unknown> {\n        return this._unselected;\n    }\n\n    @Output()\n    public get connected(): EventEmitter<unknown> {\n        return this._connected;\n    }\n\n    @Output()\n    public get disconnected(): EventEmitter<unknown> {\n        return this._disconnected;\n    }\n\n    @Output()\n    public get changed(): EventEmitter<unknown> {\n        return this._changed;\n    }\n\n    public invoke<TMethod extends WizardStepMethodNames>(method: TMethod, ...args: Parameters<WizardStepComponentMethods[TMethod]>): ReturnType<WizardStepComponentMethods[TMethod]> {\n        return (this._element as any)[method](...args);\n    }\n\n    private onEmit<T>(emitter: EventEmitter<T>, event: Event): void {\n        if (event instanceof CustomEvent) {\n            emitter.emit(event.detail);\n        } else {\n            emitter.emit();\n        }\n    }\n}\n\n/**\n * Declares the methods available on WizardStepComponent.\n */\nexport type WizardStepMethodNames = 'play' | 'onEnterAnimation' | 'onExitAnimation' | 'select' | 'unselect' | 'adoptStyle' | 'on' | 'off' | 'emit' | 'requestUpdate';\n\n/**\n * Declares the methods interface for WizardStepComponent.\n */\nexport type WizardStepComponentMethods = MethodMap<WizardStepMethodNames>;\n\n/**\n * @public\n */\nexport function provideWizardStep(config: Partial<WizardStepElement.Props>): EnvironmentProviders {\n    return makeEnvironmentProviders([\n        {\n            provide: WIZARD_STEP_DEFAULT_PROPS,\n            useValue: config\n        }\n    ]);\n}\n"]}