@cjlapao/ui-kit-vue 0.2.0 → 0.2.3

package/dist/types/common/utils/smartVariables.d.ts

@@ -1,23 +1,79 @@
-import { type SmartVariable, type SmartVariableType, type SmartVariableSource } from "../types/Variables";
+import type { SmartVariable, SmartVariableDefinition, SmartVariableGroup, SmartVariableResolver, SmartVariableSource, SmartVariableType } from "../types/Variables";
+/**
+ * Matches `{{ type::source::name }}`.
+ * Captures: 1 = type, 2 = source, 3 = name.
+ *
+ * `source` is an open identifier now — it used to be the literal alternation
+ * `global|system|service`, so a caller with its own groups produced tokens the
+ * kit silently refused to recognise.
+ */
 export declare const SMART_VAR_REGEX: RegExp;
-export declare const parseSmartVariable: (token: string) => SmartVariable | null;
 export declare const createSmartToken: (type: SmartVariableType, source: SmartVariableSource, name: string) => string;
+export declare const parseSmartVariable: (token: string) => SmartVariable | null;
+/** Every distinct token in a string, in order of first appearance. */
+export declare const extractVariables: (text: string) => SmartVariable[];
+export declare const hasSmartVariables: (text: string) => boolean;
+export type SmartValuePart = {
+    kind: "text";
+    text: string;
+    index: number;
+} | {
+    kind: "token";
+    variable: SmartVariable;
+    index: number;
+};
 /**
- * Extracts all unique variables from a given text string.
+ * Splits a value into literal text and tokens, once, for every renderer.
+ *
+ * `SmartInput`, `SmartValue`, `MarkdownEditor` and the Vue twins each carried
+ * their own copy of this `while (regex.exec(...))` loop plus its own badge
+ * palette, and they had already drifted — one required the token's type to
+ * match the definition's, another ignored it.
  */
-export declare const extractVariables: (text: string) => SmartVariable[];
-import { type CapsuleBlueprintParameter } from "../types/CapsuleBlueprint";
-interface VariableContext {
-    globalParameters?: CapsuleBlueprintParameter[];
-    serviceNames?: string[];
-    context?: {
-        slug?: string;
-        enable_https?: boolean;
-    };
-}
-export declare const resolveVariable: (value: string, ctx: VariableContext) => {
-    value: string;
-    isResolved: boolean;
-    isRuntime: boolean;
+export declare const splitSmartValue: (value: string) => SmartValuePart[];
+/** Turns one group's definitions into insertable tokens. */
+export declare const groupToVariables: (group: SmartVariableGroup) => SmartVariable[];
+export declare const toSmartVariable: (source: SmartVariableSource, definition: SmartVariableDefinition) => SmartVariable;
+/**
+ * Finds the definition a token refers to. Matches on the group id and key,
+ * falling back to a case-insensitive key match — token names are typed by
+ * hand and case slips are the common failure.
+ */
+export declare const findDefinition: (groups: SmartVariableGroup[], variable: SmartVariable) => {
+    group: SmartVariableGroup;
+    definition: SmartVariableDefinition;
+} | null;
+/**
+ * The resolver used when the caller supplies none: looks the token up in the
+ * groups and reports its `value`, then its `defaultValue`, then `missing`.
+ *
+ * Product rules — derived values, environment lookups, host names — belong in
+ * a caller-supplied resolver, not here. The kit used to hard-code one
+ * product's domain name and runtime-variable allow-list into this function.
+ */
+export declare const createDefaultResolver: (groups: SmartVariableGroup[]) => SmartVariableResolver;
+/** Resolves every token in a value, for counters and validation. */
+export declare const resolveSmartValue: (value: string, resolve: SmartVariableResolver) => {
+    text: string;
+    missing: SmartVariable[];
 };
-export {};
+/**
+ * Builds the three groups the components used to hard-code, from the old
+ * `globalParameters` / `serviceNames` props.
+ *
+ * @deprecated Pass `groups` directly. Kept so call sites written against the
+ * previous API keep working while they migrate.
+ */
+export declare const createLegacyGroups: (options: {
+    globalParameters?: Array<{
+        key: string;
+        name?: string;
+        type?: string;
+        help?: string;
+        default?: unknown;
+        default_value?: string;
+        [extra: string]: unknown;
+    }>;
+    serviceNames?: string[];
+    systemVariables?: SmartVariable[];
+}) => SmartVariableGroup[];

package/dist/types/common/utils/tableStorage.d.ts

@@ -0,0 +1,38 @@
+import type { TableSettings } from "../types/TableSettings";
+/**
+ * Built-in table settings persistence.
+ *
+ * The kit's Table exposes `storageKey`; when set, the table reads its
+ * settings once on mount and writes the full snapshot after every change.
+ * This module is framework-agnostic so the React and Vue kits share one
+ * envelope format and one validation pass.
+ *
+ * The default backend is a best-effort localStorage wrapper: it swallows
+ * quota errors, private-mode rejections and SSR (no `window`) so persistence
+ * can never crash a render. Any `Storage`-shaped object (sessionStorage, a
+ * test mock, an IndexedDB adapter) can be passed in its place.
+ */
+import { createSafeLocalStorage, type KitStorageAdapter } from "./safeStorage";
+/**
+ * The storage backend and key builder now live in `safeStorage.ts`, shared
+ * with `SmartGridLayout`. Re-exported here under their original names so
+ * `Table` and its tests are untouched.
+ */
+export type TableStorageAdapter = KitStorageAdapter;
+export { createSafeLocalStorage };
+/** Default key prefix so table entries never collide with app keys. */
+export declare const TABLE_STORAGE_DEFAULT_PREFIX = "ui-kit:table";
+/** Envelope version. Bump when the settings shape changes incompatibly. */
+export declare const TABLE_SETTINGS_STORAGE_VERSION = 1;
+export interface TableStoredSettings {
+    v: number;
+    settings: TableSettings;
+}
+export declare const buildTableStorageKey: (prefix: string, storageKey: string) => string;
+export declare const encodeStoredSettings: (settings: TableSettings) => string;
+/**
+ * Parse and validate a stored value. Returns `null` for anything that is not
+ * a current-version settings object — the component then falls back to its
+ * prop-provided defaults rather than rendering against garbage.
+ */
+export declare const decodeStoredSettings: (raw: string | null) => TableSettings | null;

package/dist/types/vue/src/chat/index.d.ts

@@ -0,0 +1,4 @@
+export * from "../../../common/chat/types";
+export * from "../../../common/chat/storage";
+export * from "../../../common/chat/stream";
+export * from "../../../common/chat/markdown";

package/dist/types/vue/src/components/AccessMatrix.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/vue/src/components/AccessMatrix.vue.d.ts

@@ -1,5 +1,7 @@
+import { type VNode, type VNodeChild } from "vue";
 import type { TableVariant } from "./Table.vue";
 import type { PanelTone } from "./Panel.vue";
+import type { TableDensity, SurfaceCorner } from "../theme";
 export interface AccessMatrixPermission {
     group: string;
     resource: string;
@@ -12,12 +14,27 @@ export interface AccessMatrixProps {
     limit?: number;
     variant?: TableVariant;
     tone?: PanelTone;
+    /** Forwards to Table: row-height density scale. */
+    density?: TableDensity;
+    /** Forwards to Table: draw the vertical grid lines between columns. */
+    bordered?: boolean;
+    /** Forwards to Table: the panel corner radius. */
+    corner?: SurfaceCorner;
     striped?: boolean;
     /** Forwards to Table: remove inner row borders/dividers. */
     noBorders?: boolean;
     /** Forwards to Table: make the table fill parent height and scroll internally. */
     fullHeight?: boolean;
     hoverable?: boolean;
+    /** Forwards to Table: show a loading skeleton shaped like the matrix. */
+    loading?: boolean;
+    /** Forwards to Table: the message shown while `loading`. */
+    loadingMessage?: string;
+    /**
+     * Forwards to Table: the node shown when there are no permissions. Defaults to
+     * `"No permissions to display"` when omitted.
+     */
+    emptyState?: VNodeChild;
     /**
      * Background Tailwind class(es) applied to the sticky Resource column cells so they remain
      * opaque over scrolled action columns. Defaults to `'bg-white dark:bg-neutral-900'`.
@@ -27,10 +44,15 @@ export interface AccessMatrixProps {
     stickyBackground?: string;
 }
 declare const _default: import("vue").DefineComponent<AccessMatrixProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<AccessMatrixProps> & Readonly<{}>, {
+    loading: boolean;
     tone: PanelTone;
     variant: TableVariant;
-    fullHeight: boolean;
     hoverable: boolean;
+    fullHeight: boolean;
+    bordered: boolean;
+    emptyState: string | number | boolean | void | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | import("vue").VNodeArrayChildren | null;
     striped: boolean;
     noBorders: boolean;
     limit: number;

package/dist/types/vue/src/components/Accordion.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/vue/src/components/Accordion.vue.d.ts

@@ -1,10 +1,14 @@
+import { type PanelPadding } from "./Panel.vue";
 import type { VNode } from "vue";
-import type { LoaderProps } from "./Loader.vue";
-import type { PanelTone } from "./Panel.vue";
-export type AccordionVariant = "default" | "bordered" | "minimal" | "tonal" | "ghost";
-export type AccordionSize = "sm" | "md" | "lg";
-export type AccordionIndicator = "chevron" | "plus-minus" | "caret" | "none";
-export type AccordionChevronPlacement = "left" | "right";
+import type { PanelProps } from "./Panel.vue";
+import { type ControlSize } from "../theme/Theme";
+/**
+ * The affordance that tells you a row can expand. The old component also
+ * offered a `caret`, which rendered the exact same `ArrowDown` glyph as
+ * `chevron` — two names, one icon — so it is gone.
+ */
+export type AccordionIndicator = "chevron" | "plus-minus" | "none";
+export type AccordionIndicatorPlacement = "left" | "right";
 export interface AccordionItem {
     id: string;
     title: string | VNode;
@@ -17,27 +21,30 @@ export interface AccordionItem {
     disabled?: boolean;
     loading?: boolean;
 }
-export interface AccordionProps {
+/**
+ * A stacked disclosure list on the shared container surface.
+ *
+ * It renders `Panel` (like `CollapsiblePanel`), so `variant`, `tone`, `corner`,
+ * `padding` and every glass prop come from the same scales as every other
+ * card. The Vue kit has no surface-text provider, so the tokens are read
+ * straight from the shared theme with this component's own `variant` — the
+ * same call `Panel` makes internally.
+ */
+export interface AccordionProps extends Omit<PanelProps, "title" | "subtitle" | "actions"> {
     items: AccordionItem[];
-    variant?: AccordionVariant;
-    tone?: PanelTone;
-    size?: AccordionSize;
+    /** Density of each row's type, icon and indicator. @default "md" */
+    size?: ControlSize;
+    /** @default "chevron" */
     indicator?: AccordionIndicator;
-    chevronPlacement?: AccordionChevronPlacement;
-    divider?: boolean;
+    /** Where the indicator sits. @default "right" */
+    indicatorPlacement?: AccordionIndicatorPlacement;
+    /** Animate expand/collapse. @default true */
     animated?: boolean;
-    transitionMs?: number;
-    iconClassName?: string;
+    ariaLabel?: string;
     itemClassName?: string;
     headerClassName?: string;
     contentClassName?: string;
-    ariaLabel?: string;
-    loading?: boolean;
-    loaderTitle?: string;
-    loaderMessage?: string;
-    loaderType?: LoaderProps["variant"];
-    loaderProgress?: number;
-    loaderColor?: LoaderProps["color"];
+    iconClassName?: string;
     defaultOpenIds?: string[];
     openIds?: string[];
     multiple?: boolean;
@@ -49,15 +56,22 @@ declare const _default: import("vue").DefineComponent<AccordionProps, {}, {}, {}
     onChange?: ((openIds: string[]) => any) | undefined;
     onItemToggle?: ((id: string, isOpen: boolean) => any) | undefined;
 }>, {
-    tone: PanelTone;
-    variant: AccordionVariant;
-    size: AccordionSize;
+    size: ControlSize;
     loading: boolean;
+    tone: import("./Gantt").TrueColor;
+    disabled: boolean;
+    variant: import("./Panel.vue").PanelVariant;
+    corner: import("./Panel.vue").PanelCorner;
+    fullWidth: boolean;
     animated: boolean;
-    loaderType: "spinner" | "progress";
+    padding: PanelPadding;
+    flexBody: boolean;
+    loaderType: import("./Panel.vue").PanelLoaderType;
+    hoverShadow: boolean;
+    hoverable: boolean;
+    scrollable: boolean;
+    specularHighlight: boolean;
     indicator: AccordionIndicator;
-    chevronPlacement: AccordionChevronPlacement;
-    divider: boolean;
-    transitionMs: number;
+    indicatorPlacement: AccordionIndicatorPlacement;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 export default _default;

package/dist/types/vue/src/components/ActivityFeed.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/vue/src/components/ActivityFeed.vue.d.ts

@@ -0,0 +1,141 @@
+import { type ButtonVariant } from "./Button.vue";
+import { type SurfaceCorner, type SurfacePadding, type SurfaceVariant, type TrueColor } from "../theme";
+/** One entry in the feed. */
+export interface ActivityFeedItem {
+    id: string;
+    /** What happened, in one line. */
+    title: string;
+    /** Supporting copy. */
+    description?: string;
+    /** A monospaced reference — a PR number, a ticket id. */
+    code?: string;
+    /** Who did it. */
+    actor?: string;
+    /** Pre-formatted ("3m ago", "09:12") — feeds rarely want live clocks. */
+    timestamp: string;
+    /** Status dot tone. @default "neutral" */
+    tone?: TrueColor;
+    /** Group this entry belongs to. Filters match it (falling back to `tone`). */
+    category?: string;
+    /** Entries this one aggregates — rendered as a count badge. */
+    count?: number;
+}
+/** A feed filter; the value `"all"` always matches. */
+export interface ActivityFeedFilter {
+    label: string;
+    value: string;
+}
+declare const _default: import("vue").DefineComponent<{
+    /** @default "Recent activity" */
+    title?: string;
+    items: ActivityFeedItem[];
+    /** Filter segment control; an "All" segment is prepended for you. */
+    filters?: ActivityFeedFilter[];
+    /** @default "all" */
+    defaultFilter?: string;
+    /** A pill beside the title (a source name, a state). */
+    tag?: string;
+    /** Trailing header link (to the full log). */
+    linkLabel?: string;
+    /**
+     * The link's button variant. Follows the card's own `variant` by default —
+     * an outlined card offers an outlined button.
+     */
+    ctaVariant?: ButtonVariant;
+    /**
+     * The Load-more button variant. Follows the card's own `variant` by default.
+     */
+    loadMoreVariant?: ButtonVariant;
+    /**
+     * The filter's track variant — the same surface vocabulary the card wears.
+     * Follows the card's own `variant`, so the track reads as a slice of the card.
+     */
+    filterVariant?: SurfaceVariant;
+    /** Tail button; emitted `loadMore` only reaches out when `hasMore`. */
+    hasMore?: boolean;
+    /**
+     * Draws the feed's own shape in placeholder ink while the events are in
+     * flight — same row rhythm, nothing jumps when they land.
+     */
+    loading?: boolean;
+    /** @default "Load more" */
+    loadMoreLabel?: string;
+    /** Shown in the header when the caller knows the true total. */
+    totalCount?: number;
+    /** Surface, as every card in the kit takes it. @default "outlined" */
+    variant?: SurfaceVariant;
+    /** @default "neutral" */
+    tone?: TrueColor;
+    /** @default "md" */
+    padding?: SurfacePadding;
+    corner?: SurfaceCorner;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    link: () => any;
+    loadMore: () => any;
+    filterChange: (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<{
+    /** @default "Recent activity" */
+    title?: string;
+    items: ActivityFeedItem[];
+    /** Filter segment control; an "All" segment is prepended for you. */
+    filters?: ActivityFeedFilter[];
+    /** @default "all" */
+    defaultFilter?: string;
+    /** A pill beside the title (a source name, a state). */
+    tag?: string;
+    /** Trailing header link (to the full log). */
+    linkLabel?: string;
+    /**
+     * The link's button variant. Follows the card's own `variant` by default —
+     * an outlined card offers an outlined button.
+     */
+    ctaVariant?: ButtonVariant;
+    /**
+     * The Load-more button variant. Follows the card's own `variant` by default.
+     */
+    loadMoreVariant?: ButtonVariant;
+    /**
+     * The filter's track variant — the same surface vocabulary the card wears.
+     * Follows the card's own `variant`, so the track reads as a slice of the card.
+     */
+    filterVariant?: SurfaceVariant;
+    /** Tail button; emitted `loadMore` only reaches out when `hasMore`. */
+    hasMore?: boolean;
+    /**
+     * Draws the feed's own shape in placeholder ink while the events are in
+     * flight — same row rhythm, nothing jumps when they land.
+     */
+    loading?: boolean;
+    /** @default "Load more" */
+    loadMoreLabel?: string;
+    /** Shown in the header when the caller knows the true total. */
+    totalCount?: number;
+    /** Surface, as every card in the kit takes it. @default "outlined" */
+    variant?: SurfaceVariant;
+    /** @default "neutral" */
+    tone?: TrueColor;
+    /** @default "md" */
+    padding?: SurfacePadding;
+    corner?: SurfaceCorner;
+}> & Readonly<{
+    onLink?: (() => any) | undefined;
+    onLoadMore?: (() => any) | undefined;
+    onFilterChange?: ((value: string) => any) | undefined;
+}>, {
+    title: string;
+    loading: boolean;
+    tone: TrueColor;
+    filters: ActivityFeedFilter[];
+    variant: SurfaceVariant;
+    tag: string;
+    padding: SurfacePadding;
+    defaultFilter: string;
+    linkLabel: string;
+    ctaVariant: ButtonVariant;
+    loadMoreVariant: ButtonVariant;
+    filterVariant: SurfaceVariant;
+    hasMore: boolean;
+    loadMoreLabel: string;
+    totalCount: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/types/vue/src/components/Alert.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/vue/src/components/Alert.vue.d.ts

@@ -1,15 +1,58 @@
 import type { VNode } from "vue";
-import type { TrueColor } from "../theme/Theme";
-export type AlertVariant = "subtle" | "solid" | "outline";
+import type { AlertIconAlign, AlertIntent, AlertVariant, ControlSize, SurfaceCorner, TrueColor } from "../theme/Theme";
+import type { GlassOpacity, GlassVibrancy, SpecularMode } from "../theme/glass";
+export type { AlertIconAlign, AlertIntent, AlertVariant };
+export type AlertSize = ControlSize;
 export interface AlertProps {
+    /**
+     * What the callout means. Picks the tone, the default icon and how assistive
+     * technology announces it. `color` overrides just the tone.
+     * @default "neutral"
+     */
+    intent?: AlertIntent;
+    /** @deprecated Use `color`, or `intent` for a semantic callout. */
     tone?: TrueColor;
+    /** Overrides the tone the `intent` would have chosen. */
     color?: TrueColor;
+    /** @default "subtle" */
     variant?: AlertVariant;
+    /** @default "md" */
+    size?: AlertSize;
+    /** Corner radius, on the shared container scale. */
+    corner?: SurfaceCorner;
     title?: string;
+    /** Body copy. The default slot is used instead when this is omitted. */
     description?: string;
+    /** A registry icon name, a node, or `false` to show none. */
     icon?: string | VNode | false;
+    /**
+     * Icon size, on the shared control scale. Defaults to a step derived from
+     * `size`, which is right in most cases — set this when the callout needs a
+     * heavier glyph than its copy would suggest.
+     */
+    iconSize?: ControlSize;
+    /**
+     * Where the icon sits against the content. @default "top"
+     */
+    iconAlign?: AlertIconAlign;
     actions?: string;
     dismissible?: boolean;
+    /**
+     * Controls visibility. Leave it unset and a dismissible alert hides itself —
+     * it used to render a dismiss button that did nothing unless the caller
+     * wired up the `dismiss` event *and* their own state.
+     */
+    open?: boolean;
+    /** Label for the dismiss button. @default "Dismiss alert" */
+    dismissLabel?: string;
+    /** Overrides the politeness the `intent` would have chosen. */
+    live?: "assertive" | "polite" | "off";
+    /** Glass fill transparency, for the glass variants. */
+    glassOpacity?: GlassOpacity;
+    /** Backdrop vibrancy, for the glass variants. */
+    vibrancy?: GlassVibrancy;
+    /** Specular highlight, for the glass variants. */
+    specularMode?: SpecularMode;
 }
 declare const _default: __VLS_WithSlots<import("vue").DefineComponent<AlertProps, {
     el: import("vue").Ref<HTMLDivElement | null, HTMLDivElement | null>;
@@ -18,9 +61,23 @@ declare const _default: __VLS_WithSlots<import("vue").DefineComponent<AlertProps
 }, string, import("vue").PublicProps, Readonly<AlertProps> & Readonly<{
     onDismiss?: (() => any) | undefined;
 }>, {
+    icon: string | VNode | false;
+    size: AlertSize;
+    intent: AlertIntent;
     variant: AlertVariant;
+    corner: SurfaceCorner;
+    iconAlign: AlertIconAlign;
     dismissible: boolean;
+    open: boolean;
+    dismissLabel: string;
+    glassOpacity: GlassOpacity;
+    vibrancy: GlassVibrancy;
+    specularMode: SpecularMode;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    title?: (props: {}) => any;
+} & {
+    default?: (props: {}) => any;
+} & {
     actions?: (props: {}) => any;
 }>;
 export default _default;

package/dist/types/vue/src/components/ApiErrorState.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/vue/src/components/ApiErrorState.vue.d.ts

@@ -1,23 +1,43 @@
 import type { EmptyStateProps } from "./EmptyState.vue";
-export interface ApiErrorStateProps extends Omit<EmptyStateProps, "title" | "tone" | "icon" | "onAction" | "buttonText"> {
+import type { ApiErrorKind } from "../theme/Theme";
+export type { ApiErrorKind };
+export interface ApiErrorStateProps extends Omit<EmptyStateProps, "onAction" | "disableBorder" | "transparentBackground"> {
+    /**
+     * What went wrong. Picks the tone, the glyph and the default copy — and
+     * whether a retry is offered at all, since a 403 does not clear by pressing
+     * a button. @default "unknown"
+     */
+    kind?: ApiErrorKind;
+    /** Called when the retry button is pressed. Omit it and no button is drawn. */
     onRetry?: () => void;
-    title?: string;
-    isError?: boolean;
+    /** The retry is in flight: the button spins and refuses a second press. */
+    retrying?: boolean;
+    /** Label on that button. @default "Try Again" */
     buttonText?: string;
+    /**
+     * Render nothing when false — for `<ApiErrorState :is-error="!!error" />` at
+     * a call site that would otherwise need a `v-if`. @default true
+     */
+    isError?: boolean;
 }
 declare const _default: __VLS_WithSlots<import("vue").DefineComponent<ApiErrorStateProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ApiErrorStateProps> & Readonly<{}>, {
-    title: string;
+    dashed: boolean;
     fullWidth: boolean;
-    subtitle: string;
     showIcon: boolean;
-    disableBorder: boolean;
-    transparentBackground: boolean;
-    fullHeight: boolean;
+    iconBackground: boolean;
     actionLeadingIcon: string | import("vue").VNode;
+    actionDisabled: boolean;
+    fullHeight: boolean;
+    kind: ApiErrorKind;
+    retrying: boolean;
     buttonText: string;
     isError: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
     title?: (props: {}) => any;
+} & {
+    subtitle?: (props: {}) => any;
+} & {
+    actions?: (props: {}) => any;
 }>;
 export default _default;
 type __VLS_WithSlots<T, S> = T & {

package/dist/types/vue/src/components/AppDivider.vue.d.ts

@@ -1,10 +1,59 @@
+import type { ControlSize, TrueColor } from "../theme/Theme";
+export type AppDividerOrientation = "vertical" | "horizontal";
+export type AppDividerLabelPosition = "start" | "center" | "end";
+export declare const APP_DIVIDER_VARIANTS: readonly ["solid", "dashed", "dotted", "gradient"];
+export type AppDividerVariant = (typeof APP_DIVIDER_VARIANTS)[number];
 export interface AppDividerProps {
-    /** Height of the divider in pixels or as CSS value */
+    /**
+     * Which way the rule runs. Stays `vertical` by default — this component was
+     * written for header sections and every existing call site relies on it.
+     * @default "vertical"
+     */
+    orientation?: AppDividerOrientation;
+    /** @default "solid" */
+    variant?: AppDividerVariant;
+    /**
+     * Accent colour. Omit it and the rule takes a neutral divider colour that
+     * works on both light and dark surfaces.
+     */
+    tone?: TrueColor;
+    /** Line thickness on the shared control scale. @default "xs" */
+    size?: ControlSize;
+    /** Space either side of the rule. @default "sm" */
+    spacing?: "none" | ControlSize;
+    /**
+     * Length along the rule's own axis — height when vertical, width when
+     * horizontal. Defaults to `1.5rem` vertical, full width horizontal.
+     */
+    length?: number | string;
+    /** Text set into the rule. The default slot overrides it. */
+    label?: string;
+    /** @default "center" */
+    labelPosition?: AppDividerLabelPosition;
+    /**
+     * Hidden from assistive technology. Defaults to true for an unlabelled rule,
+     * which is decoration; a labelled one is announced as a separator.
+     */
+    decorative?: boolean;
+    /** @deprecated Use `length`. */
     height?: number | string;
-    /** Width of the divider in pixels */
+    /** @deprecated Use `size`, or pass a number of pixels. */
     width?: number;
-    /** Margin around the divider */
+    /** @deprecated Use `spacing`. */
     margin?: number | string;
 }
-declare const _default: import("vue").DefineComponent<AppDividerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<AppDividerProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<AppDividerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<AppDividerProps> & Readonly<{}>, {
+    size: ControlSize;
+    variant: AppDividerVariant;
+    orientation: AppDividerOrientation;
+    spacing: "none" | ControlSize;
+    labelPosition: AppDividerLabelPosition;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+}>;
 export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};