@openreachtech/furo-vue 1.3.1

package/types/generated/components/organisms/FuroToast/FuroToasterContext.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Context class for FuroToaster — the single mount point that renders the
+ * global imperative toast queue through the controlled `<FuroToast>` organism.
+ * Reads the shared `ToastQueue` singleton, forwards its parcel, and routes the
+ * component's `dismiss` / `action` events back to the queue.
+ *
+ * @extends {BaseFuroContext}
+ */
+export default class FuroToasterContext extends BaseFuroContext<null, any, null> {
+    /**
+     * Factory method.
+     *
+     * @template {X extends typeof FuroToasterContext ? X : never} T, X
+     * @override
+     * @param {FuroToasterContextFactoryParams} params - Parameters of this factory method.
+     * @returns {InstanceType<T>} An instance of this class.
+     * @this {T}
+     */
+    static override create<T extends X extends typeof FuroToasterContext ? X : never, X>(this: T, { props, componentContext, queue, }: FuroToasterContextFactoryParams): InstanceType<T>;
+    /**
+     * Constructor.
+     *
+     * @param {FuroToasterContextParams} params - Parameters of this constructor.
+     */
+    constructor({ props, componentContext, queue, }: FuroToasterContextParams);
+    queue: import("./ToastQueue.js").default;
+    /**
+     * Build the parcel forwarded to `<FuroToast>`.
+     *
+     * @returns {object}
+     */
+    buildParcel(): object;
+    /**
+     * Handle a toast dismissal from `<FuroToast>`.
+     *
+     * @param {{
+     *   key: number | string
+     * }} params - Parameters of this method.
+     */
+    onDismiss({ key, }: {
+        key: number | string;
+    }): void;
+    /**
+     * Handle a toast action click from `<FuroToast>`.
+     *
+     * @param {{
+     *   key: number | string
+     *   actionKey: string
+     * }} params - Parameters of this method.
+     */
+    onAction({ key, actionKey, }: {
+        key: number | string;
+        actionKey: string;
+    }): void;
+}
+export type FuroToasterContextParams = import("../../../contexts/BaseFuroContext.js").BaseFuroContextParams & {
+    queue: import("./ToastQueue.js").default;
+};
+export type FuroToasterContextFactoryParams = Omit<FuroToasterContextParams, "queue"> & {
+    queue?: import("./ToastQueue.js").default;
+};
+import BaseFuroContext from '../../../contexts/BaseFuroContext.js';

package/types/generated/components/organisms/FuroToast/ToastQueue.d.ts

@@ -0,0 +1,201 @@
+/**
+ * Imperative toast queue backing the global `toast` helper.
+ *
+ * Holds the reactive toast list and viewport config, and bridges function
+ * handlers (`actions[].onClick`) to the controlled `<FuroToast>` parcel: the
+ * parcel it builds is JSON-serializable (handlers stripped), while the handlers
+ * stay here and are invoked from the component's `action` event. This keeps the
+ * `FuroToast` organism controlled and registry-free; the imperative singleton
+ * lives only in this opt-in layer.
+ */
+export default class ToastQueue {
+    /**
+     * Factory method.
+     *
+     * @param {{
+     *   stateReactive?: ToastQueueState
+     * }} [params] - Parameters of this factory method.
+     * @returns {ToastQueue}
+     */
+    static create({ stateReactive, }?: {
+        stateReactive?: ToastQueueState;
+    }): ToastQueue;
+    /**
+     * Resolve the one queue shared by every copy of this module in the realm.
+     *
+     * @returns {ToastQueue}
+     */
+    static resolveSharedInstance(): ToastQueue;
+    /**
+     * Build the reactive state (toast list + viewport config).
+     *
+     * @returns {ToastQueueState}
+     */
+    static buildStateReactive(): ToastQueueState;
+    /**
+     * Constructor.
+     *
+     * @param {{
+     *   stateReactive: ToastQueueState
+     * }} params - Parameters of this constructor.
+     */
+    constructor({ stateReactive, }: {
+        stateReactive: ToastQueueState;
+    });
+    stateReactive: {
+        toasts: {
+            key: number | string;
+            title: string | null;
+            description: string | null;
+            type: string;
+            durationInMilliseconds: number | null;
+            closeText: string | null;
+            actions: {
+                actionKey: string;
+                label: string;
+            }[];
+        }[];
+        config: {
+            label?: string;
+            position?: import("./FuroToastContext.js").ToastPosition;
+            swipeDirection?: import("./FuroToastContext.js").ToastSwipeDirection;
+            hotkey?: Array<string> | null;
+            durationInMilliseconds?: number;
+            maxVisible?: number;
+            richColors?: boolean;
+        };
+    };
+    nextId: number;
+    /** @type {Record<string, Record<string, () => void>>} */
+    actionHandlerHash: Record<string, Record<string, () => void>>;
+    /**
+     * get: current toast entries.
+     *
+     * @returns {Array<QueuedToast>}
+     */
+    get toasts(): Array<QueuedToast>;
+    /**
+     * Build the parcel forwarded to `<FuroToast>` (config merged with the queue).
+     *
+     * @returns {object}
+     */
+    buildParcel(): object;
+    /**
+     * Reserve and return the next stable toast key.
+     *
+     * @returns {number}
+     */
+    reserveKey(): number;
+    /**
+     * Register a toast's action handlers and return serializable descriptors.
+     *
+     * @param {{
+     *   key: number | string
+     *   actions: Array<{ label: string, onClick?: () => void }>
+     * }} params - Parameters of this method.
+     * @returns {Array<{ actionKey: string, label: string }>}
+     */
+    registerActions({ key, actions, }: {
+        key: number | string;
+        actions: Array<{
+            label: string;
+            onClick?: () => void;
+        }>;
+    }): Array<{
+        actionKey: string;
+        label: string;
+    }>;
+    /**
+     * Push a new toast onto the queue.
+     *
+     * @param {{
+     *   title?: string | null
+     *   description?: string | null
+     *   type?: string
+     *   durationInMilliseconds?: number | null
+     *   closeText?: string | null
+     *   actions?: Array<{ label: string, onClick?: () => void }>
+     * }} [params] - Parameters of this method.
+     * @returns {number} The new toast key.
+     */
+    addToast({ title, description, type, durationInMilliseconds, closeText, actions, }?: {
+        title?: string | null;
+        description?: string | null;
+        type?: string;
+        durationInMilliseconds?: number | null;
+        closeText?: string | null;
+        actions?: Array<{
+            label: string;
+            onClick?: () => void;
+        }>;
+    }): number;
+    /**
+     * Patch an existing toast (e.g. loading → success). Re-registers handlers
+     * when the patch carries new actions.
+     *
+     * @param {{
+     *   key: number | string
+     *   patch: Partial<QueuedToast>
+     * }} params - Parameters of this method.
+     */
+    updateToast({ key, patch, }: {
+        key: number | string;
+        patch: Partial<QueuedToast>;
+    }): void;
+    /**
+     * Remove a toast from the queue.
+     *
+     * @param {{
+     *   key: number | string
+     * }} params - Parameters of this method.
+     */
+    removeToast({ key, }: {
+        key: number | string;
+    }): void;
+    /**
+     * Remove all toasts.
+     */
+    clearToasts(): void;
+    /**
+     * Merge viewport configuration (position, duration, maxVisible, …).
+     *
+     * @param {ToastConfig} [params] - Configuration to merge.
+     */
+    configure(params?: ToastConfig): void;
+    /**
+     * Invoke a toast's action handler by key.
+     *
+     * @param {{
+     *   key: number | string
+     *   actionKey: string
+     * }} params - Parameters of this method.
+     */
+    invokeAction({ key, actionKey, }: {
+        key: number | string;
+        actionKey: string;
+    }): void;
+}
+/**
+ * A toast entry stored in the queue (serializable; handlers live separately).
+ */
+export type QueuedToast = {
+    key: number | string;
+    title: string | null;
+    description: string | null;
+    type: string;
+    durationInMilliseconds: number | null;
+    closeText: string | null;
+    actions: Array<{
+        actionKey: string;
+        label: string;
+    }>;
+};
+/**
+ * Viewport configuration shared by all toasts — the `<FuroToast>` parcel
+ * without the per-toast queue.
+ */
+export type ToastConfig = Omit<import("./FuroToastContext.js").ToastParcel, "toasts">;
+export type ToastQueueState = import("vue").Reactive<{
+    toasts: Array<QueuedToast>;
+    config: ToastConfig;
+}>;

package/types/generated/components/organisms/FuroToast/toast.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Realm-wide toast queue backing the `toast` helper and consumed by
+ * `<FuroToaster>`. See `docs/furo-toast.md` for the SSR caveat.
+ */
+export const toastQueue: ToastQueue;
+export namespace toast {
+    function show(params?: {
+        title?: string | null;
+        description?: string | null;
+        type?: string;
+        durationInMilliseconds?: number | null;
+        closeText?: string | null;
+        actions?: Array<{
+            label: string;
+            onClick?: () => void;
+        }>;
+    }): number;
+    function hide(key: number | string): void;
+    function update(key: number | string, patch: object): void;
+    function clear(): void;
+    function configure(params?: import("./ToastQueue.js").ToastConfig): void;
+}
+import ToastQueue from './ToastQueue.js';

package/types/generated/contexts/BaseFuroContext.d.ts

@@ -0,0 +1,207 @@
+/**
+ * Furo Component Context.
+ *
+ * @template {typeof import('./BaseFuroContextAccessor').default<*> | null} [A = null] - ContextAccessor class.
+ * @template {import('vue').ComponentCustomProps} [P = {}] - Props.
+ * @template {string | null} [EE = null] - emit() event names.
+ */
+export default class BaseFuroContext<A extends typeof import("./BaseFuroContextAccessor").default<any> | null = null, P extends import("vue").ComponentCustomProps = {}, EE extends string | null = null> {
+    /**
+     * Factory method to create a new instance of this class.
+     *
+     * @template {X extends typeof BaseFuroContext ? X : never} T, X
+     * @param {BaseFuroContextFactoryParams<{}>} params - Parameters of this factory method.
+     * @returns {InstanceType<T>} - New instance of this class.
+     * @this {T}
+     */
+    static create<T extends X extends typeof BaseFuroContext ? X : never, X>(this: T, { props, componentContext, }: BaseFuroContextFactoryParams<{}>): InstanceType<T>;
+    /**
+     * get: ContextAccessor for this class.
+     *
+     * @returns {typeof import('./BaseFuroContextAccessor').default<*> | null} - ContextAccessor class of this class.
+     */
+    static get ContextAccessor(): typeof import("./BaseFuroContextAccessor").default<any> | null;
+    /**
+     * emit() event name.
+     *
+     * @abstract
+     * @returns {Record<string, string>}
+     */
+    static get EMIT_EVENT_NAME(): Record<string, string>;
+    /**
+     * Build reactive hash.
+     *
+     * @returns {Record<string, import('vue').Reactive<*>>}
+     */
+    static buildReactiveHash(): Record<string, import("vue").Reactive<any>>;
+    /**
+     * Build ref hash.
+     *
+     * @returns {Record<string, import('vue').Ref<*>>}
+     */
+    static buildRefHash(): Record<string, import("vue").Ref<any>>;
+    /**
+     * Build shallow ref hash.
+     *
+     * @returns {Record<string, import('vue').ShallowRef<*>>}
+     */
+    static buildShallowRefHash(): Record<string, import("vue").ShallowRef<any>>;
+    /**
+     * Build model value hash.
+     *
+     * @returns {Record<string, import('vue').ModelRef<*>>}
+     */
+    static buildModelRefHash(): Record<string, import("vue").ModelRef<any>>;
+    /**
+     * Create MutationObserver.
+     *
+     * @param {{
+     *   handler: MutationCallback
+     * }} args - Arguments of this method.
+     * @returns {MutationObserver} - New instance of MutationObserver.
+     */
+    static createMutationObserver({ handler, }: {
+        handler: MutationCallback;
+    }): MutationObserver;
+    /**
+     * Constructor.
+     *
+     * @param {BaseFuroContextParams<P>} params - Parameters of this constructor.
+     */
+    constructor({ props, componentContext, reactiveHash, refHash, shallowRefHash, modelRefHash, }: BaseFuroContextParams<P>);
+    props: P & {
+        parcel?: any;
+    };
+    componentContext: {
+        attrs: import("vue").Attrs;
+        slots: Readonly<{
+            [name: string]: import("vue").Slot<any>;
+        }>;
+        emit: (event: unknown, ...args: any[]) => void;
+        expose: <Exposed extends Record<string, any> = Record<string, any>>(exposed?: Exposed) => void;
+    };
+    reactiveHash: {};
+    refHash: {};
+    shallowRefHash: {};
+    modelRefHash: {};
+    accessor: import("./BaseFuroContextAccessor").default<any>;
+    /**
+     * Get the constructor of this class.
+     *
+     * @returns {typeof BaseFuroContext<*, *, *>}
+     */
+    get Ctor(): typeof BaseFuroContext<any, any, any>;
+    /**
+     * get: ContextAccessor for this class.
+     *
+     * @returns {import('./BaseFuroContextAccessor').default<*> | null} - ContextAccessor class of this class.
+     */
+    createContextAccessor(): import("./BaseFuroContextAccessor").default<any> | null;
+    /**
+     * get: An instance of ContextAccessor.
+     *
+     * @returns {InstanceType<A>} - An instance of ContextAccessor.
+     */
+    get $(): InstanceType<A>;
+    /**
+     * get: emit() event name.
+     *
+     * @returns {Record<string, EE>} - emit() event name.
+     */
+    get EMIT_EVENT_NAME(): Record<string, EE>;
+    /**
+     * get: parcel of props.
+     *
+     * @returns {P['parcel'] | null} - Parcel from props.
+     */
+    get parcel(): P["parcel"] | null;
+    /**
+     * get: attrs of component context.
+     *
+     * @returns {import('vue').SetupContext['attrs']} - Attributes of component context.
+     */
+    get attrs(): import("vue").SetupContext["attrs"];
+    /**
+     * get: slots of component context.
+     *
+     * @returns {(
+     *   event: EE,
+     *   ...args: Array<any>
+     * ) => void} - emit() function of component context.
+     */
+    get emit(): (event: EE, ...args: Array<any>) => void;
+    /**
+     * get: expose() of component context.
+     *
+     * @returns {import('vue').SetupContext['expose']} - Listeners of component context.
+     */
+    get expose(): import("vue").SetupContext["expose"];
+    /**
+     * get: slots of component context.
+     *
+     * @returns {import('vue').SetupContext['slots']} - Slots of component context.
+     */
+    get slots(): import("vue").SetupContext["slots"];
+    /**
+     * get: watch() of component context.
+     *
+     * @returns {import('vue').watch} - Watch of component context.
+     */
+    get watch(): typeof watch;
+    /**
+     * Whether a fallthrough attribute is on. Presence decides, as in HTML: every value
+     * reads as on, the bare attribute's '' and 0 included, except false and absent.
+     *
+     * @param {{
+     *   name: string
+     * }} params - Parameters of this method.
+     * @returns {boolean} - Whether the attribute is on.
+     */
+    hasBooleanAttribute({ name, }: {
+        name: string;
+    }): boolean;
+    /**
+     * Setup component context.
+     *
+     * @template T
+     * @param {object} [args] - Arguments of this method.
+     * @returns {T} - For method chaining.
+     * @this {T}
+     * @example
+     * ```
+     * setupComponent (args) {
+     *   this..expose(
+     *     this.generateExposeHash()
+     *   )
+     *
+     *   watch(
+     *     [
+     *       this.rootElementRef,
+     *     ],
+     *     this.generateWatchRootElementHandler()
+     *   )
+     *
+     *   return this
+     * }
+     * ```
+     */
+    setupComponent<T>(this: T, args?: object): T;
+    /**
+     * Generate expose() hash.
+     *
+     * @returns {Record<string, Function>} - expose() hash.
+     */
+    generateExposeHash(): Record<string, Function>;
+}
+export type BaseFuroContextParams<P extends import("vue").ComponentCustomProps | {} = {}, EE extends string | null = null, ReactiveHash extends Record<string, import("vue").Reactive<any>> = {}, RefHash extends Record<string, import("vue").Ref<any>> = {}, ShallowRefHash extends Record<string, import("vue").ShallowRef<any>> = {}, ModelRefHash extends Record<string, import("vue").ModelRef<any>> = {}> = {
+    props: P & {
+        parcel?: any;
+    };
+    componentContext: import("vue").SetupContext<EE>;
+    reactiveHash?: ReactiveHash;
+    refHash?: RefHash;
+    shallowRefHash?: ShallowRefHash;
+    modelRefHash?: ModelRefHash;
+};
+export type BaseFuroContextFactoryParams<P extends import("vue").ComponentCustomProps | {} = {}, EE extends string | null = null> = BaseFuroContextParams<P>;
+import { watch } from 'vue';

package/types/generated/contexts/BaseFuroContextAccessor.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Base class for all context accessors.
+ *
+ * @template {import('./BaseFuroContext').default<*>} C
+ * @property {C} context - Context.
+ */
+export default class BaseFuroContextAccessor<C extends import("./BaseFuroContext").default<any>> {
+    /**
+     * Factory method to create a new instance of this class.
+     *
+     * @template {X extends typeof BaseFuroContextAccessor<*> ? X : never} T, X
+     * @param {BaseFuroContextAccessorFactoryParams} params - Parameters of this factory method.
+     * @returns {InstanceType<T>} - New instance of this class.
+     * @this {T}
+     */
+    static create<T extends X extends typeof BaseFuroContextAccessor<any> ? X : never, X>(this: T, { context, }: BaseFuroContextAccessorFactoryParams): InstanceType<T>;
+    /**
+     * Constructor.
+     *
+     * @param {BaseFuroContextAccessorParams<C>} params - Parameters of this constructor.
+     */
+    constructor({ context, }: BaseFuroContextAccessorParams<C>);
+    context: C;
+}
+export type BaseFuroContextAccessorParams<C extends import("./BaseFuroContext").default<any>> = {
+    context: C;
+};
+export type BaseFuroContextAccessorFactoryParams = BaseFuroContextAccessorParams<any>;

package/types/generated/emit-payload/BaseEmitPayload.d.ts

@@ -0,0 +1,62 @@
+/**
+ * BaseEmitPayload.
+ *
+ * @template {Event} [E = Event] - Event.
+ * @template {HTMLElement} [C = HTMLElement] - Control element.
+ */
+export default class BaseEmitPayload<E extends Event = Event, C extends HTMLElement = HTMLElement> {
+    /**
+     * Factory method of this class.
+     *
+     * @template {X extends typeof BaseEmitPayload ? X : never} T, X
+     * @param {BaseEmitPayloadFactoryParams<*>} params - Parameters of this factory method.
+     * @returns {InstanceType<T>} - A new instance of this class.
+     * @this {T}
+     */
+    static create<T extends X extends typeof BaseEmitPayload ? X : never, X>(this: T, { rawEvent, }: BaseEmitPayloadFactoryParams<any>): InstanceType<T>;
+    /**
+     * Constructor of this class.
+     *
+     * @param {BaseEmitPayloadParams<E>} params - Parameters of this constructor.
+     */
+    constructor({ rawEvent, }: BaseEmitPayloadParams<E>);
+    rawEvent: E;
+    /**
+     * Get the control element from the raw event.
+     *
+     * @returns {C | null} - The control element from the raw event.
+     */
+    get controlElement(): C | null;
+    /**
+     * Read a DOM attribute from the control element.
+     *
+     * @param {{
+     *   key: string
+     * }} params - Parameters of this method.
+     * @returns {string | null} - Attribute value, or `null` when the control or attribute is missing.
+     */
+    getElementAttribute({ key, }: {
+        key: string;
+    }): string | null;
+    /**
+     * Parse a string as a number (e.g. after reading an attribute).
+     *
+     * @param {{
+     *   stringValue: string | null
+     * }} params - Parameters of this method.
+     * @returns {number | null} - Parsed number, or `null` when `stringValue` is `null`.
+     */
+    parseStringAsNumber({ stringValue, }: {
+        stringValue: string | null;
+    }): number | null;
+}
+/**
+ * <E>
+ */
+export type BaseEmitPayloadParams<E extends Event> = {
+    rawEvent: E;
+};
+/**
+ * <E>
+ */
+export type BaseEmitPayloadFactoryParams<E extends Event> = BaseEmitPayloadParams<E>;

package/types/generated/index.components.d.ts

@@ -0,0 +1,50 @@
+export { default as FuroAvatar } from "./components/atoms/FuroAvatar/FuroAvatar.vue";
+export { default as FuroBadge } from "./components/atoms/FuroBadge/FuroBadge.vue";
+export { default as FuroButton } from "./components/atoms/FuroButton/FuroButton.vue";
+export { default as FuroCheckbox } from "./components/atoms/FuroCheckbox/FuroCheckbox.vue";
+export { default as FuroEmailField } from "./components/atoms/FuroEmailField/FuroEmailField.vue";
+export { default as FuroFileField } from "./components/atoms/FuroFileField/FuroFileField.vue";
+export { default as FuroIcon } from "./components/atoms/FuroIcon/FuroIcon.vue";
+export { default as FuroNumberField } from "./components/atoms/FuroNumberField/FuroNumberField.vue";
+export { default as FuroPasswordField } from "./components/atoms/FuroPasswordField/FuroPasswordField.vue";
+export { default as FuroRadio } from "./components/atoms/FuroRadio/FuroRadio.vue";
+export { default as FuroSwitch } from "./components/atoms/FuroSwitch/FuroSwitch.vue";
+export { default as FuroTextField } from "./components/atoms/FuroTextField/FuroTextField.vue";
+export { default as FuroTextarea } from "./components/atoms/FuroTextarea/FuroTextarea.vue";
+export { default as FuroToggle } from "./components/atoms/FuroToggle/FuroToggle.vue";
+export { default as FuroAccordion } from "./components/molecules/FuroAccordion/FuroAccordion.vue";
+export { default as FuroAttachment } from "./components/molecules/FuroAttachment/FuroAttachment.vue";
+export { default as FuroAutocompleteField } from "./components/molecules/FuroAutocompleteField/FuroAutocompleteField.vue";
+export { default as FuroAvatarGroup } from "./components/molecules/FuroAvatarGroup/FuroAvatarGroup.vue";
+export { default as FuroBreadcrumb } from "./components/molecules/FuroBreadcrumb/FuroBreadcrumb.vue";
+export { default as FuroCollapsible } from "./components/molecules/FuroCollapsible/FuroCollapsible.vue";
+export { default as FuroControlBlock } from "./components/molecules/FuroControlBlock/FuroControlBlock.vue";
+export { default as FuroDatePicker } from "./components/molecules/FuroDatePicker/FuroDatePicker.vue";
+export { default as FuroDateTimePicker } from "./components/molecules/FuroDateTimePicker/FuroDateTimePicker.vue";
+export { default as FuroDropdownMenu } from "./components/molecules/FuroDropdownMenu/FuroDropdownMenu.vue";
+export { default as FuroEditableField } from "./components/molecules/FuroEditableField/FuroEditableField.vue";
+export { default as FuroEmptyState } from "./components/molecules/FuroEmptyState/FuroEmptyState.vue";
+export { default as FuroErrorState } from "./components/molecules/FuroErrorState/FuroErrorState.vue";
+export { default as FuroPagination } from "./components/molecules/FuroPagination/FuroPagination.vue";
+export { default as FuroPopover } from "./components/molecules/FuroPopover/FuroPopover.vue";
+export { default as FuroScrollArea } from "./components/molecules/FuroScrollArea/FuroScrollArea.vue";
+export { default as FuroSearchField } from "./components/molecules/FuroSearchField/FuroSearchField.vue";
+export { default as FuroSectionHeader } from "./components/molecules/FuroSectionHeader/FuroSectionHeader.vue";
+export { default as FuroSelect } from "./components/molecules/FuroSelect/FuroSelect.vue";
+export { default as FuroSeparator } from "./components/molecules/FuroSeparator/FuroSeparator.vue";
+export { default as FuroSkeleton } from "./components/molecules/FuroSkeleton/FuroSkeleton.vue";
+export { default as FuroSplitter } from "./components/molecules/FuroSplitter/FuroSplitter.vue";
+export { default as FuroTimeField } from "./components/molecules/FuroTimeField/FuroTimeField.vue";
+export { default as FuroToggleGroup } from "./components/molecules/FuroToggleGroup/FuroToggleGroup.vue";
+export { default as FuroToolBar } from "./components/molecules/FuroToolBar/FuroToolBar.vue";
+export { default as FuroTooltip } from "./components/molecules/FuroTooltip/FuroTooltip.vue";
+export { default as FuroAlertDialog } from "./components/organisms/FuroAlertDialog/FuroAlertDialog.vue";
+export { default as FuroDialog } from "./components/organisms/FuroDialog/FuroDialog.vue";
+export { default as FuroDrawer } from "./components/organisms/FuroDrawer/FuroDrawer.vue";
+export { default as FuroEditor } from "./components/organisms/FuroEditor/FuroEditor.vue";
+export { default as FuroSidebar } from "./components/organisms/FuroSidebar/FuroSidebar.vue";
+export { default as FuroStepper } from "./components/organisms/FuroStepper/FuroStepper.vue";
+export { default as FuroTable } from "./components/organisms/FuroTable/FuroTable.vue";
+export { default as FuroTabs } from "./components/organisms/FuroTabs/FuroTabs.vue";
+export { default as FuroToast } from "./components/organisms/FuroToast/FuroToast.vue";
+export { default as FuroToaster } from "./components/organisms/FuroToast/FuroToaster.vue";

package/types/generated/index.core.d.ts

@@ -0,0 +1,6 @@
+export { default as BaseFuroContext } from "./contexts/BaseFuroContext.js";
+export { default as BaseFuroContextAccessor } from "./contexts/BaseFuroContextAccessor.js";
+export { furoIconRegistry } from "./components/atoms/FuroIcon/icons.js";
+export { default as FuroIconRegistry } from "./components/atoms/FuroIcon/FuroIconRegistry.js";
+export { default as ToastQueue } from "./components/organisms/FuroToast/ToastQueue.js";
+export { toast, toastQueue } from "./components/organisms/FuroToast/toast.js";