@synopackageland/ui 0.4.2 → 0.5.3

package/dist/components/composite/wizard/Wizard.vue.d.ts

@@ -0,0 +1,68 @@
+import { WizardFooterConfig, WizardStepChange } from './types';
+/**
+ * Step-flow controller for multi-step dialogs. It owns step registration,
+ * navigation guards, footer state and the finish / cancel outcomes. It creates
+ * no window: mount it inside `Dialog` for app-local modality.
+ */
+type __VLS_Props = {
+    /** Initial / external reset key. Internal navigation keeps working when the caller does not bind it back. */
+    activeStepKey?: string;
+    footer?: WizardFooterConfig;
+    /** Shows the Cancel action in the footer. */
+    cancellable?: boolean;
+    ariaLabel?: string;
+};
+declare function toNextStep(): Promise<void>;
+declare function toPreviousStep(): Promise<void>;
+declare function finish(): Promise<void>;
+declare function cancel(): void;
+declare var __VLS_1: {}, __VLS_3: {
+    nextStep: typeof toNextStep;
+    previousStep: typeof toPreviousStep;
+    finish: typeof finish;
+    cancel: typeof cancel;
+    canGoPrevious: boolean;
+    isLastStep: boolean;
+    busy: boolean;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+} & {
+    footer?: (props: typeof __VLS_3) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {
+    activeStepKey: import('vue').ComputedRef<string>;
+    currentStepIndex: import('vue').ComputedRef<number>;
+    totalSteps: import('vue').ComputedRef<number>;
+    canGoPrevious: import('vue').ComputedRef<boolean>;
+    isLastStep: import('vue').ComputedRef<boolean>;
+    busy: import('vue').Ref<boolean, boolean>;
+    toNextStep: typeof toNextStep;
+    toPreviousStep: typeof toPreviousStep;
+    finish: typeof finish;
+    cancel: typeof cancel;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    cancel: () => any;
+    "update:activeStepKey": (key: string) => any;
+    "next-step": (change: WizardStepChange) => any;
+    "previous-step": (change: WizardStepChange) => any;
+    finished: () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onCancel?: (() => any) | undefined;
+    "onUpdate:activeStepKey"?: ((key: string) => any) | undefined;
+    "onNext-step"?: ((change: WizardStepChange) => any) | undefined;
+    "onPrevious-step"?: ((change: WizardStepChange) => any) | undefined;
+    onFinished?: (() => any) | undefined;
+}>, {
+    footer: WizardFooterConfig;
+    ariaLabel: string;
+    cancellable: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/composite/wizard/WizardStep.vue.d.ts

@@ -0,0 +1,20 @@
+import { WizardStepProps } from './types';
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<WizardStepProps, {
+    active: import('vue').ComputedRef<boolean>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<WizardStepProps> & Readonly<{}>, {
+    footer: boolean;
+    type: import('./types').WizardStepType;
+    headline: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/composite/wizard/types.d.ts

@@ -0,0 +1,32 @@
+export type WizardStepType = 'normal' | 'welcome';
+/** A guard may return `false` (or resolve `false`) to block the step change. */
+export type MaybePromise<T> = T | Promise<T>;
+export type WizardStepProps = {
+    /** Unique key the wizard uses to identify this step. */
+    stepKey: string;
+    /** `'welcome'` is the entry step and only offers the forward action. */
+    type?: WizardStepType;
+    headline?: string;
+    /** Omitted on the final step: the forward button then becomes Apply. */
+    nextStepKey?: string | (() => string);
+    /** Omitted falls back to the step registered just before this one. */
+    previousStepKey?: string | (() => string);
+    /** Async guard run before moving forward. `false` blocks the change. */
+    preEnterNextStep?: () => MaybePromise<false | void>;
+    /** Async guard run before moving back. `false` blocks the change. */
+    preEnterPreviousStep?: () => MaybePromise<false | void>;
+    /** Runs when the final Apply action succeeds. */
+    finished?: () => MaybePromise<void>;
+    /** `false` hides the shared footer while this step is active. */
+    footer?: boolean;
+};
+export type WizardFooterConfig = boolean | {
+    previousLabel?: string;
+    nextLabel?: string;
+    applyLabel?: string;
+    cancelLabel?: string;
+};
+export type WizardStepChange = {
+    from: string;
+    to: string;
+};

package/dist/components/composite/wizard/wizardContext.d.ts

@@ -0,0 +1,17 @@
+import { ComputedRef, InjectionKey, Ref } from 'vue';
+import { WizardStepProps } from './types';
+/** A mounted `WizardStep` as seen by its `Wizard`. `props` stays reactive. */
+export type WizardStepRegistration = {
+    key: string;
+    props: WizardStepProps;
+};
+export type WizardContext = {
+    activeStepKey: ComputedRef<string | undefined>;
+    steps: Ref<WizardStepRegistration[]>;
+    busy: Ref<boolean>;
+    register: (registration: WizardStepRegistration) => void;
+    unregister: (key: string) => void;
+};
+export declare const wizardKey: InjectionKey<WizardContext>;
+/** `WizardStep` uses this; it stays inert when it has no `Wizard` ancestor. */
+export declare function useWizardContext(): WizardContext | null;

package/dist/components/containers/card/Card.vue.d.ts

@@ -0,0 +1,42 @@
+type __VLS_Props = {
+    title?: string;
+    layoutType?: 'regular' | 'compact';
+    /** `false` hides the whole header row (title and actions together). */
+    hasHeader?: boolean;
+    /** Renders the disclosure arrow and collapses the body. */
+    expandable?: boolean;
+    /** Bound with `v-model:expanded`; defaults to expanded when left unbound. */
+    expanded?: boolean;
+    /** Accessible name for the disclosure arrow when the card has no title. */
+    toggleLabel?: string;
+};
+declare var __VLS_8: {}, __VLS_10: {}, __VLS_17: {}, __VLS_19: {}, __VLS_21: {};
+type __VLS_Slots = {} & {
+    title?: (props: typeof __VLS_8) => any;
+} & {
+    'header-actions'?: (props: typeof __VLS_10) => any;
+} & {
+    body?: (props: typeof __VLS_17) => any;
+} & {
+    default?: (props: typeof __VLS_19) => any;
+} & {
+    footer?: (props: typeof __VLS_21) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:expanded": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:expanded"?: ((value: boolean) => any) | undefined;
+}>, {
+    expandable: boolean;
+    expanded: boolean;
+    layoutType: "regular" | "compact";
+    hasHeader: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/containers/expandable-item/ExpandableItem.vue.d.ts

@@ -0,0 +1,79 @@
+import { Component } from 'vue';
+export type ExpandableItemText = string | {
+    text: string;
+    /** `html` injects `text` verbatim; the caller owns the safety of that string. */
+    format?: 'text' | 'html';
+    /** `true` shows `text` only while the line is truncated, a string always shows it. */
+    tip?: string | boolean;
+};
+export type ExpandableItemDisabled = boolean | {
+    allowExpand?: boolean;
+};
+type __VLS_Props = {
+    title?: ExpandableItemText;
+    summary?: ExpandableItemText;
+    /** Main icon; use the `icon` slot for a fully custom node. */
+    icon?: Component;
+    /** Small status badge rendered on the icon corner. */
+    statusIcon?: Component;
+    /** Bound with `v-model:expanded`. */
+    expanded?: boolean;
+    /** Defaults to `true` when the `detail` slot is present. */
+    expandable?: boolean;
+    /**
+     * `true` disables the whole row, `{ allowExpand: true }` greys the row but
+     * keeps the disclosure working.
+     */
+    disabled?: ExpandableItemDisabled;
+    selected?: boolean;
+    /** Enables native drag emission (`drag-start`, `drag-over`, `drop`, `drag-end`). */
+    draggable?: boolean;
+    /** Emits `select` when the summary row is clicked. */
+    selectable?: boolean;
+};
+declare var __VLS_1: {}, __VLS_8: {}, __VLS_15: {}, __VLS_17: {}, __VLS_19: {}, __VLS_21: {}, __VLS_23: {}, __VLS_25: {};
+type __VLS_Slots = {} & {
+    icon?: (props: typeof __VLS_1) => any;
+} & {
+    'icon-status'?: (props: typeof __VLS_8) => any;
+} & {
+    title?: (props: typeof __VLS_15) => any;
+} & {
+    status?: (props: typeof __VLS_17) => any;
+} & {
+    label?: (props: typeof __VLS_19) => any;
+} & {
+    block?: (props: typeof __VLS_21) => any;
+} & {
+    detail?: (props: typeof __VLS_23) => any;
+} & {
+    'toggle-icon'?: (props: typeof __VLS_25) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (event: MouseEvent) => any;
+    drop: (event: DragEvent) => any;
+    "update:expanded": (value: boolean) => any;
+    "drag-start": (event: DragEvent) => any;
+    "drag-over": (event: DragEvent) => any;
+    "drag-end": (event: DragEvent) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSelect?: ((event: MouseEvent) => any) | undefined;
+    onDrop?: ((event: DragEvent) => any) | undefined;
+    "onUpdate:expanded"?: ((value: boolean) => any) | undefined;
+    "onDrag-start"?: ((event: DragEvent) => any) | undefined;
+    "onDrag-over"?: ((event: DragEvent) => any) | undefined;
+    "onDrag-end"?: ((event: DragEvent) => any) | undefined;
+}>, {
+    selectable: boolean;
+    expandable: boolean;
+    draggable: boolean;
+    expanded: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/containers/fieldset/Fieldset.vue.d.ts

@@ -0,0 +1,58 @@
+export type FieldsetTitle = string | {
+    text: string;
+    format?: 'text' | 'html';
+};
+export type FieldsetCollapseTrigger = 'click' | 'dblclick' | 'none';
+type __VLS_Props = {
+    title?: FieldsetTitle;
+    collapsible?: boolean;
+    /** Mouse gesture that toggles; Enter/Space always works on the header. */
+    collapseTriggerEvent?: FieldsetCollapseTrigger;
+    collapseIcon?: 'left' | 'none';
+    /** Bound with `v-model:collapsed`; defaults to expanded when left unbound. */
+    collapsed?: boolean;
+};
+declare var __VLS_1: {}, __VLS_8: {}, __VLS_10: {}, __VLS_12: {};
+type __VLS_Slots = {} & {
+    'collapse-icon'?: (props: typeof __VLS_1) => any;
+} & {
+    title?: (props: typeof __VLS_8) => any;
+} & {
+    title?: (props: typeof __VLS_10) => any;
+} & {
+    default?: (props: typeof __VLS_12) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {
+    isCollapsed: import('vue').ComputedRef<boolean>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:collapsed": (value: boolean) => any;
+    collapsestatechange: (value: boolean) => any;
+    beforebodyenter: (element: HTMLElement | null) => any;
+    afterbodyenter: (element: HTMLElement | null) => any;
+    beforebodyleave: (element: HTMLElement | null) => any;
+    afterbodyleave: (element: HTMLElement | null) => any;
+    "header-click": () => any;
+    "header-dblclick": () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:collapsed"?: ((value: boolean) => any) | undefined;
+    onCollapsestatechange?: ((value: boolean) => any) | undefined;
+    onBeforebodyenter?: ((element: HTMLElement | null) => any) | undefined;
+    onAfterbodyenter?: ((element: HTMLElement | null) => any) | undefined;
+    onBeforebodyleave?: ((element: HTMLElement | null) => any) | undefined;
+    onAfterbodyleave?: ((element: HTMLElement | null) => any) | undefined;
+    "onHeader-click"?: (() => any) | undefined;
+    "onHeader-dblclick"?: (() => any) | undefined;
+}>, {
+    collapsible: boolean;
+    collapsed: boolean;
+    collapseTriggerEvent: FieldsetCollapseTrigger;
+    collapseIcon: "left" | "none";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/containers/highlight-box/HighlightBox.vue.d.ts

@@ -0,0 +1,23 @@
+type __VLS_Props = {
+    color?: 'blue' | 'grey';
+    /** Skip the built-in inner padding wrapper so the slot owns its layout. */
+    hideInnerCls?: boolean;
+};
+declare var __VLS_1: {}, __VLS_3: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+} & {
+    default?: (props: typeof __VLS_3) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    color: "blue" | "grey";
+    hideInnerCls: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/containers/panel/Panel.vue.d.ts

@@ -0,0 +1,59 @@
+import { FootbarButton } from '../../composite/footbar/types';
+export type PanelFbarConfig = {
+    /** Set to `false` to hide the built-in confirm button, or override its fields. */
+    confirm?: false | Partial<FootbarButton>;
+    /** Set to `false` to hide the built-in cancel button, or override its fields. */
+    cancel?: false | Partial<FootbarButton>;
+    /** Replace the whole button row instead of tweaking confirm/cancel. */
+    buttons?: FootbarButton[];
+};
+export type PanelFbar = boolean | PanelFbarConfig;
+type __VLS_Props = {
+    loading?: boolean;
+    loadingText?: string;
+    /** `true` shows the built-in Confirm/Cancel row, `false` hides the footer. */
+    fbar?: PanelFbar;
+    confirmText?: string;
+    cancelText?: string;
+    /** Make the default body slot scroll when its content overflows. */
+    scrollable?: boolean;
+};
+declare var __VLS_1: {}, __VLS_3: {}, __VLS_5: {}, __VLS_7: {}, __VLS_9: {}, __VLS_18: {};
+type __VLS_Slots = {} & {
+    tbar?: (props: typeof __VLS_1) => any;
+} & {
+    'scroll-body'?: (props: typeof __VLS_3) => any;
+} & {
+    body?: (props: typeof __VLS_5) => any;
+} & {
+    default?: (props: typeof __VLS_7) => any;
+} & {
+    fbar?: (props: typeof __VLS_9) => any;
+} & {
+    'spin-inner'?: (props: typeof __VLS_18) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {
+    getScrollEl: () => HTMLElement | null;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    cancel: (button: FootbarButton) => any;
+    "click-button": (button: FootbarButton, event: MouseEvent) => any;
+    confirm: (button: FootbarButton) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onCancel?: ((button: FootbarButton) => any) | undefined;
+    "onClick-button"?: ((button: FootbarButton, event: MouseEvent) => any) | undefined;
+    onConfirm?: ((button: FootbarButton) => any) | undefined;
+}>, {
+    loading: boolean;
+    fbar: PanelFbar;
+    confirmText: string;
+    cancelText: string;
+    scrollable: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/feedback/info-mask/InfoMask.vue.d.ts

@@ -0,0 +1,22 @@
+type __VLS_Props = {
+    active?: boolean;
+    ariaLabel?: string;
+};
+declare var __VLS_1: {}, __VLS_3: {};
+type __VLS_Slots = {} & {
+    inner?: (props: typeof __VLS_1) => any;
+} & {
+    default?: (props: typeof __VLS_3) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    ariaLabel: string;
+    active: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/feedback/info-tip/InfoTip.vue.d.ts

@@ -0,0 +1,53 @@
+type TriggerAction = 'hover' | 'click' | 'adaptive';
+type InfoTipType = 'normal' | 'white';
+type InfoTipSize = 'normal' | 'small';
+type __VLS_Props = {
+    content?: string;
+    triggerAction?: TriggerAction;
+    type?: InfoTipType;
+    size?: InfoTipSize;
+    showDelay?: number;
+    hideDelay?: number;
+    disabled?: boolean;
+    forceSimple?: boolean;
+    hasPadding?: boolean;
+    ariaLabel?: string;
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    /** Optional portal container factory, as in SVC's `tipContainer`. */
+    tipContainer?: () => HTMLElement | null | undefined;
+};
+type __VLS_Slots = {
+    default?: () => unknown;
+    custom?: () => unknown;
+};
+declare function showTooltip(): void;
+declare function hideTooltip(): void;
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {
+    showTooltip: typeof showTooltip;
+    hideTooltip: typeof hideTooltip;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    activate: () => any;
+    deactivate: () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onActivate?: (() => any) | undefined;
+    onDeactivate?: (() => any) | undefined;
+}>, {
+    size: InfoTipSize;
+    type: InfoTipType;
+    disabled: boolean;
+    ariaLabel: string;
+    side: "top" | "right" | "bottom" | "left";
+    hasPadding: boolean;
+    triggerAction: TriggerAction;
+    showDelay: number;
+    hideDelay: number;
+    forceSimple: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/feedback/notification/Notification.vue.d.ts

@@ -0,0 +1,50 @@
+import { NotificationAction, NotificationTone } from './notification';
+type __VLS_Props = {
+    id?: string;
+    title?: string | false;
+    content?: string | false;
+    tone?: NotificationTone;
+    icon?: NotificationTone | false;
+    cancel?: NotificationAction;
+    confirm?: NotificationAction;
+    duration?: number | false;
+    /** Controlled by the provider while a notification animates out. */
+    open?: boolean;
+    /** External pause, used by the provider while the whole stack is hovered or focused. */
+    paused?: boolean;
+    closeLabel?: string;
+};
+type __VLS_Slots = {
+    icon?: () => unknown;
+    title?: () => unknown;
+    content?: () => unknown;
+    actions?: () => unknown;
+    footer?: () => unknown;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    cancel: () => any;
+    close: () => any;
+    confirm: () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onCancel?: (() => any) | undefined;
+    onClose?: (() => any) | undefined;
+    onConfirm?: (() => any) | undefined;
+}>, {
+    title: string | false;
+    open: boolean;
+    tone: NotificationTone;
+    content: string | false;
+    closeLabel: string;
+    duration: number | false;
+    cancel: NotificationAction;
+    confirm: NotificationAction;
+    paused: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/feedback/notification/NotificationProvider.vue.d.ts

@@ -0,0 +1,36 @@
+import { NotificationController } from './notification';
+type NotificationAlignment = 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left';
+type __VLS_Props = {
+    /** How many notifications show while the stack is collapsed; `false` never stacks. */
+    stackSize?: number | false;
+    alignment?: NotificationAlignment;
+    /** Gap between notifications in the expanded layout, in pixels. */
+    gap?: number;
+    /** Offset between the cards of a collapsed stack, in pixels. */
+    stackGap?: number;
+    /** Default auto-close delay in milliseconds for notifications that do not set one. */
+    duration?: number;
+    landmarkLabel?: string;
+    accessHint?: string;
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, NotificationController, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    duration: number;
+    stackSize: number | false;
+    alignment: NotificationAlignment;
+    gap: number;
+    stackGap: number;
+    landmarkLabel: string;
+    accessHint: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/feedback/notification/notification.d.ts

@@ -0,0 +1,45 @@
+import { InjectionKey } from 'vue';
+export type NotificationTone = 'info' | 'suggest' | 'error';
+export type NotificationActionConfig = {
+    text: string;
+    variant?: 'primary' | 'secondary' | 'ghost' | 'danger';
+    size?: 'sm' | 'md' | 'lg';
+    disabled?: boolean;
+};
+/** `true` shows the default label, `false` hides the button, a string sets the label. */
+export type NotificationAction = string | boolean | NotificationActionConfig;
+export type NotificationOptions = {
+    id?: string;
+    title?: string | false;
+    content?: string | false;
+    tone?: NotificationTone;
+    /** `false` hides the icon; a tone overrides the colour of `tone`. */
+    icon?: NotificationTone | false;
+    cancel?: NotificationAction;
+    confirm?: NotificationAction;
+    /** Milliseconds before auto-close; `false` keeps the notification until it is dismissed. */
+    duration?: number | false;
+    /** Runs on cancel; unlike the close button it does not dismiss the notification. */
+    onCancel?: () => void;
+    /** Runs on confirm; unlike the close button it does not dismiss the notification. */
+    onConfirm?: () => void;
+    onClose?: () => void;
+};
+export type NotificationItem = {
+    id: string;
+    open: boolean;
+    options: NotificationOptions;
+};
+export type NotificationDestroy = () => void;
+export type NotificationController = {
+    notify: (options: NotificationOptions | string) => NotificationDestroy;
+    info: (options: NotificationOptions | string) => NotificationDestroy;
+    suggest: (options: NotificationOptions | string) => NotificationDestroy;
+    error: (options: NotificationOptions | string) => NotificationDestroy;
+    dismiss: (id: string) => void;
+    dismissAll: () => void;
+};
+export declare const notificationControllerKey: InjectionKey<NotificationController>;
+export declare function useNotification(): NotificationController;
+/** SVC naming for the same controller, for code moving over from `useNotifyManager()`. */
+export declare const useNotifyManager: typeof useNotification;

package/dist/components/feedback/validation-popup/ValidationPopup.vue.d.ts

@@ -0,0 +1,41 @@
+type __VLS_Props = {
+    content?: string;
+    /** `true` turns the popup off completely, including the exposed show/hide methods. */
+    disable?: boolean;
+    open?: boolean;
+    defaultOpen?: boolean;
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    align?: 'start' | 'center' | 'end';
+    offset?: number;
+    /** Optional portal container factory, matching the rest of the overlay components. */
+    tipContainer?: () => HTMLElement | null | undefined;
+};
+type __VLS_Slots = {
+    default?: () => unknown;
+    content?: () => unknown;
+};
+declare function showPopup(): void;
+declare function hidePopup(): void;
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {
+    showPopup: typeof showPopup;
+    hidePopup: typeof hidePopup;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:open": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+}>, {
+    side: "top" | "right" | "bottom" | "left";
+    align: "start" | "center" | "end";
+    defaultOpen: boolean;
+    open: boolean;
+    offset: number;
+    disable: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};