@smart-wizard/core 0.0.0-stage → 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Dipu Rajendran
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,44 @@
-# Temporary Holding Version
+# @smart-wizard/core
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+**The framework-agnostic engine for SmartWizard.**  
+Zero dependencies · TypeScript · Accessible · Extensible · Themeable
+
+> This package is part of the **[SmartWizard](https://github.com/techlab/smart-wizard)** project, the next-generation continuation of the popular jQuery SmartWizard.
+
+---
+
+## 📖 Documentation & Links
+
+* 📚 **Full Documentation & Guides**: [GitHub Readme](https://github.com/techlab/smart-wizard#readme)
+* 🌐 **Official Website & Demos**: [techlaboratory.net/smart-wizard](https://techlaboratory.net/smart-wizard)
+* 🐙 **Repository**: [github.com/techlab/smart-wizard](https://github.com/techlab/smart-wizard)
+* 🐛 **Issue Tracker**: [github.com/techlab/smart-wizard/issues](https://github.com/techlab/smart-wizard/issues)
+
+---
+
+## 📥 Installation
+
+```bash
+npm install @smart-wizard/core @smart-wizard/ui
+```
+
+---
+
+## ⚡ Quick Example
+
+```javascript
+import { SmartWizard } from '@smart-wizard/core';
+import '@smart-wizard/ui/full';
+import '@smart-wizard/ui/themes/arrows.css'; // optional theme
+
+const wizard = new SmartWizard('#wizard', {
+  theme: 'arrows',
+  transition: { effect: 'slideHorizontal', speed: 400 },
+});
+```
+
+---
+
+## 📝 License
+
+Dual-licensed under [MIT](https://github.com/techlab/smart-wizard/blob/main/LICENSE) (open-source) and [Commercial License](https://techlaboratory.net/smart-wizard#license).

package/dist/index.d.mts

@@ -0,0 +1,592 @@
+type ContentDirection = "ltr" | "rtl";
+type ColorScheme = 'auto' | 'dark' | 'light' | 'none';
+type WizardLayout = 'horizontal' | 'vertical';
+type WizardColor = 'default' | 'blue' | 'violet' | string;
+type StepDirection = 'forward' | 'backward' | 'none';
+type StepPosition = 'first' | 'middle' | 'last';
+type StepState = 'default' | 'active' | 'completed' | 'disabled' | 'hidden' | 'error' | 'warning';
+interface WizardOptions {
+    initialStep: number;
+    theme: string;
+    colorScheme: ColorScheme;
+    layout: WizardLayout;
+    color: WizardColor;
+    behavior: Behavior;
+    navigation: Navigation;
+    transition: Transition;
+    keyboardNavigation: KeyboardNavigation;
+    stepStates: {
+        completed: number[];
+        disabled: number[];
+        hidden: number[];
+        error: number[];
+        warning: number[];
+    };
+    swipeNavigation: SwipeNavigation;
+    scrollToView: boolean;
+    contentLoader: ContentLoader | null;
+}
+interface Behavior {
+    autoHeight: boolean;
+    useUrlHash: boolean;
+    supportBrowserHistory: boolean;
+}
+interface Navigation {
+    enabled: boolean;
+    alwaysClickable: boolean;
+    completed: {
+        enabled: boolean;
+        completeAllPreviousSteps: boolean;
+        clearOnBack: boolean;
+        clickable: boolean;
+    };
+}
+interface Transition {
+    effect: 'default' | 'none' | 'fade' | 'slideHorizontal' | 'slideVertical' | 'slideSwing' | 'css' | string;
+    speed: number;
+    easing: string;
+    css: {
+        prefix: string;
+        forward: {
+            show: string;
+            hide: string;
+        };
+        backward: {
+            show: string;
+            hide: string;
+        };
+    };
+}
+interface KeyboardNavigation {
+    enabled: boolean;
+    keys: {
+        left: string[];
+        right: string[];
+    };
+}
+interface SwipeNavigation {
+    enabled: boolean;
+    threshold: number;
+}
+type ContentLoader = (stepIndex: number, stepDirection: StepDirection, stepPosition: StepPosition, stepElement: HTMLElement, callback: (content: string | Node) => void) => void;
+type TransitionCallback = () => void;
+interface TransitionHandler {
+    (next: HTMLElement, current: HTMLElement | null, stepDirection: StepDirection, wizard: WizardInterface, callback: TransitionCallback): void;
+}
+interface StepItem {
+    step: HTMLElement;
+    page: HTMLElement;
+}
+/**
+ * Contract for a single wizard step wrapper.
+ * Implemented by `WizardStep`. Declared here to avoid circular imports
+ * between `types.ts` ↔ `WizardStep.ts`.
+ */
+interface IWizardStep {
+    /** Zero-based index of this step. */
+    readonly index: number;
+    /** The nav anchor `<a>` / `<button>` element. */
+    readonly element: HTMLElement;
+    /** The content panel element. */
+    readonly page: HTMLElement;
+    /** Returns `true` if the given state class is applied. */
+    hasState(state: StepState): boolean;
+    /** Returns `true` if this is the currently active step. */
+    isActive(): boolean;
+    /** Returns `true` if the step has the `disabled` state. */
+    isDisabled(): boolean;
+    /** Returns `true` if the step has the `completed` state. */
+    isCompleted(): boolean;
+    /** Returns `true` if the step has the `hidden` state. */
+    isHidden(): boolean;
+    state(s: StepState): this;
+    removeState(s: StepState): this;
+    /** Remove **all** state classes from this step. */
+    reset(): this;
+    disable(): this;
+    enable(): this;
+    complete(): this;
+    warning(): this;
+    error(): this;
+    show(): this;
+    hide(): this;
+}
+/**
+ * Contract for a collection of wizard steps supporting bulk operations.
+ * Implemented by `WizardStepCollection`.
+ */
+interface IWizardStepCollection {
+    /** Number of steps in the collection. */
+    readonly length: number;
+    state(s: StepState): this;
+    removeState(s: StepState): this;
+    /** Clear all state classes from every step in the collection. */
+    reset(): this;
+    disable(): this;
+    enable(): this;
+    complete(): this;
+    warning(): this;
+    error(): this;
+    show(): this;
+    hide(): this;
+}
+/** Controls the wizard's loading overlay. */
+interface WizardLoader {
+    /** Show the loading overlay (`sw-loading` class on the root element). */
+    show(): void;
+    /** Hide the loading overlay. */
+    hide(): void;
+}
+/**
+ * The public API surface that extensions receive in every hook.
+ * Extension packages should depend on this interface rather than
+ * the concrete `SmartWizard` class, keeping the dependency graph clean.
+ */
+interface WizardInterface {
+    readonly options: WizardOptions;
+    readonly stepItems: StepItem[];
+    readonly activeIndex: number;
+    /** The currently active step as a `WizardStep` object. */
+    readonly activeStep: IWizardStep;
+    /** Current progress as a percentage (0–100). 0% on the first step, 100% on the last. */
+    readonly progress: number;
+    /** `true` if there is a showable step after the current one. */
+    readonly canGoNext: boolean;
+    /** `true` if there is a showable step before the current one. */
+    readonly canGoPrev: boolean;
+    readonly main: HTMLElement;
+    readonly container: HTMLElement;
+    next(): void;
+    prev(): void;
+    goTo(stepIndex: number, options?: {
+        force?: boolean;
+    }): void;
+    reset(): void;
+    /**
+     * Return a `WizardStep` wrapper for the step at the given index.
+     * @example wizard.step(2).disable();
+     */
+    step(index: number): IWizardStep;
+    /**
+     * Return a `WizardStepCollection` for the given indices, or **all** steps
+     * if no indices are provided.
+     * @example wizard.steps([1, 2, 3]).disable();
+     * @example wizard.steps().reset();
+     */
+    steps(indexes?: number[]): IWizardStepCollection;
+    readonly width: number;
+    readonly height: number;
+    updateHeight(): void;
+    readonly info: WizardInfo;
+    /** Controls the wizard loading overlay. */
+    readonly loader: WizardLoader;
+}
+interface StepInfo {
+    currentStep: number;
+    totalSteps: number;
+}
+/** Aggregated snapshot of the wizard's current runtime state. */
+interface WizardInfo {
+    /** Current and total step counts. */
+    stepInfo: StepInfo;
+    /** Text flow direction of the wizard content area. */
+    contentDirection: ContentDirection;
+    /** Active layout mode. */
+    layout: WizardLayout;
+    /** Active color scheme. */
+    colorScheme: ColorScheme;
+    /** Width of the root wizard element in pixels. */
+    width: number;
+    /** Height of the root wizard element in pixels. */
+    height: number;
+}
+interface Transitions {
+    [key: string]: TransitionHandler;
+}
+/** Arguments passed to `onBeforeShow`. */
+interface ExtensionBeforeShowArgs {
+    /** Index of the step about to be shown. */
+    stepIdx: number;
+    /** Index of the step that is currently active (-1 on initial load). */
+    activeIndex: number;
+    /** Direction of the navigation. */
+    direction: StepDirection;
+}
+/** Arguments passed to `onAfterShow`. */
+interface ExtensionAfterShowArgs {
+    /** Index of the step that was just shown. */
+    stepIdx: number;
+    /** Direction of the navigation. */
+    direction: StepDirection;
+}
+/**
+ * A `WizardExtension` is a plain object that hooks into the SmartWizard lifecycle.
+ * All hooks are optional.
+ *
+ * @example
+ * const myExtension: WizardExtension = {
+ *   name: 'my-extension',
+ *   onBeforeShow(wizard, { stepIdx, direction }) {
+ *     if (!validate(stepIdx)) return false; // cancel navigation
+ *   },
+ * };
+ * wizard.extend(myExtension);
+ */
+interface WizardExtension {
+    /** Unique identifier — used to prevent duplicate registration. */
+    readonly name: string;
+    /**
+     * Called once immediately after the extension is registered via `extend()`.
+     * Use this to set up any state your extension needs.
+     */
+    onInstall?(wizard: WizardInterface): void;
+    /**
+     * Called every time `init()` runs: on construction, after `setOptions()`, and after `reset()`.
+     * Use this to re-apply DOM mutations that init() might have undone.
+     */
+    onInit?(wizard: WizardInterface): void;
+    /**
+     * Called after the wizard finishes loading and the first step is shown.
+     * Fires on construction and after `setOptions()` / `reset()`.
+     */
+    onLoad?(wizard: WizardInterface): void;
+    /**
+     * Called just before a step transition begins.
+     * Return `false` or `Promise<false>` to **cancel** the navigation.
+     *
+     * @example Async validation
+     * async onBeforeShow(wizard, { stepIdx, activeIndex }) {
+     *   const ok = await myApi.validateStep(activeIndex);
+     *   if (!ok) return false;
+     * }
+     */
+    onBeforeShow?(wizard: WizardInterface, args: ExtensionBeforeShowArgs): Promise<boolean | void> | boolean | void;
+    /**
+     * Called after a step transition completes and the new page is visible.
+     */
+    onAfterShow?(wizard: WizardInterface, args: ExtensionAfterShowArgs): void;
+    /**
+     * Called when `destroy()` is invoked on the wizard.
+     * Use this to clean up any resources your extension allocated.
+     */
+    onDestroy?(wizard: WizardInterface): void;
+}
+interface StepEventArgs {
+    stepIndex: number;
+    stepElement: HTMLElement | null;
+    stepDirection: StepDirection;
+    stepPosition: StepPosition;
+}
+interface LeaveStepEventArgs extends StepEventArgs {
+    nextStepIndex: number;
+}
+interface WizardEvents {
+    initialized: {
+        wizard: SmartWizard;
+    };
+    loaded: {
+        wizard: SmartWizard;
+    };
+    showStep: StepEventArgs;
+    leaveStep: LeaveStepEventArgs;
+    stepChanged: {
+        currentStep: number;
+        previousStep: number;
+    };
+}
+type EventCallback$1<T = any> = (event: CustomEvent<T>) => void;
+
+/**
+ * A first-class wrapper around a single wizard step.
+ * All mutating methods return `this` for fluent chaining.
+ *
+ * @example
+ * wizard.step(2).disable();
+ * wizard.step(3).state('error').state('warning'); // chain multiple states
+ */
+declare class WizardStep implements IWizardStep {
+    private readonly _index;
+    private readonly _item;
+    /** Accessor so isActive() always reflects the live wizard state. */
+    private readonly _getActiveIndex;
+    constructor(_index: number, _item: StepItem, 
+    /** Accessor so isActive() always reflects the live wizard state. */
+    _getActiveIndex: () => number);
+    /** Zero-based index of this step in the wizard. */
+    get index(): number;
+    /** The nav anchor element for this step. */
+    get element(): HTMLElement;
+    /** The content panel element for this step. */
+    get page(): HTMLElement;
+    /** Returns `true` if the given state class is currently applied to this step. */
+    hasState(state: StepState): boolean;
+    /** Returns `true` if this is the currently active step. */
+    isActive(): boolean;
+    /** Returns `true` if the step has the `disabled` state. */
+    isDisabled(): boolean;
+    /** Returns `true` if the step has the `completed` state. */
+    isCompleted(): boolean;
+    /** Returns `true` if the step has the `hidden` state. */
+    isHidden(): boolean;
+    /**
+     * Add a state class to this step.
+     * @example wizard.step(2).state('error');
+     */
+    state(s: StepState): this;
+    /**
+     * Remove a state class from this step.
+     * @example wizard.step(2).removeState('disabled');
+     */
+    removeState(s: StepState): this;
+    /**
+     * Remove **all** state classes from this step, returning it to a blank slate.
+     * @example wizard.step(2).reset();
+     */
+    reset(): this;
+    /** Mark this step as disabled (prevents navigation). */
+    disable(): this;
+    /** Remove the `disabled` state from this step. */
+    enable(): this;
+    /** Mark this step as completed. */
+    complete(): this;
+    /** Mark this step with a warning. */
+    warning(): this;
+    /** Mark this step with an error. */
+    error(): this;
+    /** Make this step visible (removes the `hidden` state). */
+    show(): this;
+    /** Hide this step (adds the `hidden` state). */
+    hide(): this;
+    private _stateToClass;
+}
+
+/**
+ * A collection of `WizardStep` objects that supports bulk state operations.
+ * All mutating methods return `this` for fluent chaining.
+ *
+ * @example
+ * wizard.steps([1, 2, 3]).disable();
+ * wizard.steps().reset();           // reset ALL steps
+ * wizard.steps([0, 1]).complete().show();
+ */
+declare class WizardStepCollection implements IWizardStepCollection {
+    private readonly _steps;
+    constructor(_steps: WizardStep[]);
+    /** Number of steps in this collection. */
+    get length(): number;
+    /**
+     * Iterate over every step in the collection.
+     * Returns `this` for fluent chaining.
+     */
+    forEach(callback: (step: WizardStep, index: number) => void): this;
+    /**
+     * Add a state class to every step in the collection.
+     * @example wizard.steps([0, 1]).state('disabled');
+     */
+    state(s: StepState): this;
+    /**
+     * Remove a state class from every step in the collection.
+     * @example wizard.steps([0, 1]).removeState('disabled');
+     */
+    removeState(s: StepState): this;
+    /**
+     * Clear all state classes from every step in the collection.
+     * @example wizard.steps().reset();
+     */
+    reset(): this;
+    /** Disable every step in the collection. */
+    disable(): this;
+    /** Enable (un-disable) every step in the collection. */
+    enable(): this;
+    /** Mark every step in the collection as completed. */
+    complete(): this;
+    /** Mark every step in the collection with a warning. */
+    warning(): this;
+    /** Mark every step in the collection with an error. */
+    error(): this;
+    /** Make every step in the collection visible. */
+    show(): this;
+    /** Hide every step in the collection. */
+    hide(): this;
+}
+
+declare class SmartWizard implements WizardInterface {
+    private _options;
+    readonly main: HTMLElement;
+    container: HTMLElement;
+    protected nav: HTMLElement;
+    stepItems: StepItem[];
+    private contentDirection;
+    private isInitialized;
+    private _activeIndex;
+    private touchStartX;
+    private touchStartY;
+    private readonly emitter;
+    private readonly binder;
+    private readonly registry;
+    private navScroll;
+    private stateManager;
+    private navigator;
+    private progressBar;
+    private navButtons;
+    private static _instanceCounter;
+    readonly id: string;
+    constructor(element: HTMLElement | string, options?: Partial<WizardOptions>);
+    private setup;
+    private _generateWizardId;
+    private init;
+    private load;
+    private resetDataAttributes;
+    private getInitialStep;
+    private setElements;
+    private setColorScheme;
+    private setNav;
+    private setEvents;
+    private setAnchor;
+    private setButtons;
+    private setProgressbar;
+    private showStep;
+    private loadContent;
+    private navigate;
+    private navigateToIndex;
+    private getStepByAnchor;
+    private getURLHashIndex;
+    private setURLHash;
+    private recalculateHeight;
+    /**
+     * Register one or more extensions. Safe to call before or after init().
+     * Returns `this` for fluent chaining.
+     */
+    extend(...exts: WizardExtension[]): this;
+    /** Index of the active step */
+    get activeIndex(): number;
+    /** Length of the steps */
+    get stepLength(): number;
+    /**
+     * Return a `WizardStep` wrapper for the step at the given index.
+     * @example wizard.step(2).disable();
+     * @example wizard.step(0).complete().show();
+     */
+    step(index: number): WizardStep;
+    /**
+     * Return a `WizardStepCollection` for the given indices.
+     * When called with no arguments, wraps **all** steps.
+     * @example wizard.steps([1, 2, 3]).disable();
+     * @example wizard.steps().reset();
+     */
+    steps(indexes?: number[]): WizardStepCollection;
+    /** The currently active step as a `WizardStep` object. */
+    get activeStep(): WizardStep;
+    /**
+     * Current progress as a percentage (0–100).
+     * 0% on the first step, 100% on the last step.
+     */
+    get progress(): number;
+    /** `true` if there is a showable step after the current one. */
+    get canGoNext(): boolean;
+    /** `true` if there is a showable step before the current one. */
+    get canGoPrev(): boolean;
+    /** Configuration */
+    get options(): Readonly<WizardOptions>;
+    get width(): number;
+    get height(): number;
+    /** Returns an aggregated snapshot of the wizard's current runtime state. */
+    get info(): WizardInfo;
+    next(): void;
+    prev(): void;
+    first(): void;
+    last(): void;
+    goTo(stepIndex: number, options?: {
+        force?: boolean;
+    }): void;
+    reset(): void;
+    setOptions(options: Partial<WizardOptions>): void;
+    getOptions(): WizardOptions;
+    /**
+     * Controls the wizard loading overlay.
+     *
+     * @example
+     * wizard.loader.show();
+     * // ... async work ...
+     * wizard.loader.hide();
+     */
+    get loader(): WizardLoader;
+    updateHeight(): void;
+    on<K extends keyof WizardEvents>(eventName: K, callback: EventCallback$1<WizardEvents[K]>): this;
+    off<K extends keyof WizardEvents>(eventName: K, callback?: EventCallback$1<WizardEvents[K]>): this;
+    once<K extends keyof WizardEvents>(eventName: K, callback: EventCallback$1<WizardEvents[K]>): this;
+    /**
+     * Destroy the wizard and remove all event listeners and styles
+     */
+    destroy(): void;
+}
+
+declare const defaultOptions: WizardOptions;
+
+declare const transitions: Record<string, TransitionHandler>;
+/**
+ * Register a custom transition effect.
+ *
+ * @param name    - Unique transition name used in `options.transition.effect`.
+ * @param handler - The transition function to execute.
+ *
+ * @example
+ * import { registerTransition } from '@smart-wizard/core';
+ *
+ * registerTransition('myFlip', (next, current, direction, wizard, done) => {
+ *   // your animation logic
+ *   done();
+ * });
+ *
+ * new SmartWizard('#wz', { transition: { effect: 'myFlip' } });
+ */
+declare function registerTransition(name: string, handler: TransitionHandler): void;
+
+type ElementCallback = (element: HTMLElement) => void;
+type EventCallback = (event: Event) => void;
+declare const applyTo: (value: Element | Element[] | NodeListOf<Element>, cb: ElementCallback) => void;
+declare const getElement: (selector: string) => HTMLElement | null;
+declare const getElements: (selector: string) => HTMLElement[];
+declare const getChildren: (selector: string, root?: Element | Document | any) => HTMLElement[];
+declare const getFirstDescendant: (selector: string, parent?: Element | Document | any) => HTMLElement | null;
+declare const getAllDescendants: (selector: string, parent?: Element | Document | any) => HTMLElement[];
+declare const addClass: (className: string, element: Element | Element[] | NodeListOf<Element>) => void;
+declare const removeClass: (className: string, element: Element | Element[] | NodeListOf<Element>) => void;
+declare const removeClassByPrefix: (element: Element | Element[] | NodeListOf<Element>, classNamePrefix: string) => void;
+declare const hasClass: (className: string, element: HTMLElement) => boolean;
+declare const showElement: (element: Element | Element[] | NodeListOf<Element>) => void;
+declare const hideElement: (element: Element | Element[] | NodeListOf<Element>) => void;
+declare const addEvent: (element: Element | Element[] | NodeListOf<Element> | Window | Document, event: keyof HTMLElementEventMap | keyof WindowEventMap, listener: EventCallback) => void;
+declare const dispatchEvent: (element: HTMLElement, eventName: string, data?: CustomEventInit) => boolean;
+declare const getAttribute: (element: HTMLElement, attributeName: string) => string | null;
+declare const setAttribute: (el: HTMLElement, attributeName: string, value: string) => void;
+declare const getElementHeight: (element: HTMLElement) => string;
+declare const setElementHeight: (element: HTMLElement, value: string) => void;
+declare const setElementWidth: (element: HTMLElement, value: string) => void;
+declare const getElementWidth: (element: HTMLElement) => number;
+/**
+ * Sets content on an element safely.
+ * - `string` → assigned to `textContent` (XSS-safe for plain text)
+ * - `Node`   → replaces children via `appendChild`
+ * Use this instead of `setHtml` when the content is not trusted HTML.
+ */
+declare const setContent: (element: HTMLElement, content: string | Node) => void;
+/** @deprecated Use `setContent()` for safe content assignment. Direct innerHTML usage is an XSS risk. */
+declare const setHtml: (element: HTMLElement, content: string) => void;
+/** @deprecated Use DOM APIs directly. Direct innerHTML concatenation is an XSS risk. */
+declare const appendHTML: (element: HTMLElement, content: string) => void;
+/** @deprecated Use DOM APIs directly. Direct innerHTML concatenation is an XSS risk. */
+declare const prependHTML: (element: HTMLElement, content: string) => void;
+/**
+ * Returns true only if `cls` is a safe, plain CSS class name.
+ * Prevents CSS injection attacks in dynamic class assignment.
+ * Allows: letters, digits, hyphens, underscores. Must start with a letter or underscore.
+ */
+declare const isSafeCssClass: (cls: string) => boolean;
+declare const appendElement: (element: HTMLElement, content: HTMLElement) => void;
+declare const prependElement: (element: HTMLElement, content: HTMLElement) => void;
+declare const triggerEvent: (el: HTMLElement, eventName: string, data?: {}) => boolean;
+declare const deepMerge: <T extends Record<string, any>>(target: T, ...sources: Partial<T>[]) => T;
+declare const mergeOptions: (target: WizardOptions, ...sources: Partial<WizardOptions>[]) => WizardOptions;
+
+export { type Behavior, type ColorScheme, type ContentDirection, type ContentLoader, type ElementCallback, type EventCallback$1 as EventCallback, type ExtensionAfterShowArgs, type ExtensionBeforeShowArgs, type IWizardStep, type IWizardStepCollection, type KeyboardNavigation, type LeaveStepEventArgs, type Navigation, SmartWizard, type StepDirection, type StepEventArgs, type StepInfo, type StepItem, type StepPosition, type StepState, type SwipeNavigation, type Transition, type TransitionCallback, type TransitionHandler, type Transitions, type WizardColor, type WizardEvents, type WizardExtension, type WizardInfo, type WizardInterface, type WizardLayout, type WizardLoader, type WizardOptions, WizardStep, WizardStepCollection, addClass, addEvent, appendElement, appendHTML, applyTo, deepMerge, defaultOptions, dispatchEvent, getAllDescendants, getAttribute, getChildren, getElement, getElementHeight, getElementWidth, getElements, getFirstDescendant, hasClass, hideElement, isSafeCssClass, mergeOptions, prependElement, prependHTML, registerTransition, removeClass, removeClassByPrefix, setAttribute, setContent, setElementHeight, setElementWidth, setHtml, showElement, transitions, triggerEvent };