@pgcorp/ui-kit 0.10.0 → 0.10.2

package/dist/src/components/shared/controls/_internal/SInlineTokenSurface.vue_vue_type_script_lang.js

@@ -0,0 +1,195 @@
+import { X as e } from "../../../icons/_internal/generatedSputnigUiIconComponents.js";
+import { useUiKitLocale as t } from "../../../../composables/useUiKitLocale.js";
+import { validateBoundedInteger as n } from "../../../../internal/runtimeContract.js";
+import { useInteractiveLeafRegistration as r } from "../../../../internal/passiveContentContract.js";
+import i from "../SButton.vue.js";
+import { computed as a, createTextVNode as o, defineComponent as s, h as c } from "vue";
+//#region src/components/shared/controls/_internal/SInlineTokenSurface.vue?vue&type=script&lang.ts
+var l = i;
+function u(e, t, r) {
+	let i = n("SInlineTokenEditor", "rows", e, {
+		minimum: 1,
+		maximum: 100
+	}), a = n("SInlineTokenEditor", "maxRows", t, {
+		minimum: 0,
+		maximum: 100
+	});
+	if (a !== 0 && a < i) throw RangeError(`SInlineTokenEditor: maxRows должен быть 0 или >= rows (${i}); получено ${a}. / SInlineTokenEditor: maxRows must be 0 or >= rows (${i}); received ${a}.`);
+	let o = r === "ghost" ? 0 : 1, s = r === "ghost" ? 1.26875 : 1.3125, c = { minHeight: `${s * i + o}rem` };
+	return a > 0 ? (c.maxHeight = `${s * a + o}rem`, c.overflowY = "auto") : (c.maxHeight = "none", c.overflowY = "visible"), c;
+}
+var d = s({
+	name: "SInlineTokenSurface",
+	inheritAttrs: !1,
+	props: {
+		id: {
+			type: String,
+			required: !0
+		},
+		elementRef: {
+			type: Function,
+			required: !0
+		},
+		ownedAttributes: {
+			type: Object,
+			required: !0
+		},
+		fieldBindings: {
+			type: Object,
+			required: !0
+		},
+		segments: {
+			type: Array,
+			required: !0
+		},
+		trailingCaretHelper: {
+			type: Boolean,
+			required: !0
+		},
+		openDisabled: {
+			type: Boolean,
+			required: !0
+		},
+		removeDisabled: {
+			type: Boolean,
+			required: !0
+		},
+		appearance: {
+			type: String,
+			required: !0
+		},
+		invalid: {
+			type: Boolean,
+			required: !0
+		},
+		disabled: {
+			type: Boolean,
+			required: !0
+		},
+		readonly: {
+			type: Boolean,
+			required: !0
+		},
+		required: {
+			type: Boolean,
+			required: !0
+		},
+		rows: {
+			type: Number,
+			required: !0
+		},
+		maxRows: {
+			type: Number,
+			required: !0
+		},
+		placeholder: {
+			type: String,
+			default: void 0
+		},
+		placeholderVisible: {
+			type: Boolean,
+			required: !0
+		},
+		labelledBy: {
+			type: String,
+			default: void 0
+		},
+		describedBy: {
+			type: String,
+			default: void 0
+		}
+	},
+	emits: {
+		beforeinput: (e) => !0,
+		input: (e) => !0,
+		keydown: (e) => !0,
+		keyup: (e) => !0,
+		click: (e) => !0,
+		paste: (e) => !0,
+		tokenAction: (e) => (e.action === "open" || e.action === "remove") && typeof e.occurrenceId == "string" && e.occurrenceId.length > 0 && typeof e.id == "string" && e.id.length > 0
+	},
+	setup(n, { emit: i }) {
+		let { t: s } = t();
+		r({
+			owner: "SInlineTokenEditor",
+			active: () => !n.disabled
+		});
+		let d = a(() => u(n.rows, n.maxRows, n.appearance)), f = (e) => e.stopPropagation(), p = (e, t, n) => {
+			e.stopPropagation(), i("tokenAction", {
+				action: t,
+				occurrenceId: n.occurrenceId,
+				id: n.id
+			});
+		}, m = (t, r) => {
+			let i = t === "open" ? {
+				label: r.label,
+				"aria-label": s("forms.openToken", { label: r.title ?? r.label }),
+				...r.title === void 0 ? {} : { title: r.title },
+				size: "xs",
+				width: "fit",
+				appearance: "text",
+				shape: "pill",
+				disabled: n.openDisabled,
+				onClick: (e) => p(e, t, r),
+				onKeydown: f
+			} : {
+				leadingIcon: e,
+				"aria-label": s("forms.removeToken", { label: r.label }),
+				size: "xs",
+				appearance: "ghost",
+				shape: "circle",
+				iconOnly: !0,
+				disabled: n.removeDisabled,
+				onClick: (e) => p(e, t, r),
+				onKeydown: f
+			};
+			return c(l, {
+				...i,
+				key: t
+			});
+		};
+		return () => c("div", {
+			...n.ownedAttributes,
+			...n.fieldBindings,
+			id: n.id,
+			ref: n.elementRef,
+			class: "s-inline-token-editor",
+			"data-appearance": n.appearance,
+			"data-invalid": n.invalid || void 0,
+			"data-disabled": n.disabled || void 0,
+			"data-readonly": n.readonly || void 0,
+			"data-placeholder": n.placeholder,
+			"data-placeholder-visible": n.placeholderVisible ? "true" : "false",
+			"data-component": "s-inline-token-editor",
+			style: d.value,
+			role: "textbox",
+			"aria-multiline": "true",
+			contenteditable: n.disabled || n.readonly ? "false" : "true",
+			tabindex: n.disabled ? -1 : 0,
+			"aria-disabled": n.disabled || void 0,
+			"aria-invalid": n.invalid || void 0,
+			"aria-required": n.required || void 0,
+			"aria-readonly": n.readonly || void 0,
+			"aria-labelledby": n.labelledBy,
+			"aria-describedby": n.describedBy,
+			onBeforeinput: (e) => i("beforeinput", e),
+			onInput: (e) => i("input", e),
+			onKeydown: (e) => i("keydown", e),
+			onKeyup: (e) => i("keyup", e),
+			onClick: (e) => i("click", e),
+			onPaste: (e) => i("paste", e)
+		}, [...n.segments.map((e) => e.kind === "text" ? o(e.text) : c("span", {
+			key: `token:${e.occurrenceId}`,
+			class: "s-inline-token-editor__token",
+			"data-testid": "s-inline-token-editor-token",
+			"data-segment-kind": "token",
+			"data-segment-occurrence-id": e.occurrenceId,
+			"data-segment-id": e.id,
+			"data-segment-label": e.label,
+			"data-segment-title": e.title,
+			contenteditable: "false"
+		}, [m("open", e), m("remove", e)])), ...n.trailingCaretHelper ? [o("​")] : []]);
+	}
+});
+//#endregion
+export { d as default };

package/dist/src/components/shared/controls/menu.d.ts

@@ -0,0 +1,52 @@
+import { Component } from 'vue';
+import { BadgeSeverity } from '../data-display/SBadge.vue';
+import { LinkDestination } from './SLink';
+export type SMenuItemLayout = 'row' | 'tile';
+export type SMenuCheckedState = boolean | 'mixed';
+export type SMenuActivationEvent = MouseEvent | KeyboardEvent;
+interface SMenuLabelledEntry {
+    readonly id: string;
+    readonly label: string;
+    readonly icon?: Component;
+    readonly disabled?: boolean;
+    readonly shortcut?: string;
+    readonly badge?: string | number;
+    readonly badgeSeverity?: BadgeSeverity;
+    readonly layout?: SMenuItemLayout;
+}
+/** Команда без собственной navigation-state semantics. / A command without navigation-state semantics. */
+export interface SMenuAction extends SMenuLabelledEntry {
+    readonly kind: 'action';
+    readonly current?: boolean;
+}
+/** Навигационное назначение с ровно одним href/to target. / A navigation destination with exactly one href/to target. */
+export type SMenuDestination = SMenuLabelledEntry & LinkDestination & {
+    readonly kind: 'destination';
+    readonly current?: boolean;
+};
+/** Управляемый checkbox intent; parent обновляет checked-state. / A controlled checkbox intent; the parent updates checked state. */
+export interface SMenuCheckbox extends SMenuLabelledEntry {
+    readonly kind: 'checkbox';
+    readonly checked: SMenuCheckedState;
+}
+/** Управляемый radio intent внутри стабильной groupId. / A controlled radio intent within a stable groupId. */
+export interface SMenuRadio extends SMenuLabelledEntry {
+    readonly kind: 'radio';
+    readonly groupId: string;
+    readonly checked: boolean;
+}
+/** Ветка вложенного меню; сама не является доменной командой. / A nested-menu branch; it is not itself a domain command. */
+export interface SMenuSubmenu extends SMenuLabelledEntry {
+    readonly kind: 'submenu';
+    readonly children: readonly SMenuEntry[];
+}
+export interface SMenuSeparatorEntry {
+    readonly kind: 'separator';
+    readonly id: string;
+}
+export type SMenuSelectableEntry = SMenuAction | SMenuDestination | SMenuCheckbox | SMenuRadio;
+export type SMenuInteractiveEntry = SMenuSelectableEntry | SMenuSubmenu;
+export type SMenuEntry = SMenuInteractiveEntry | SMenuSeparatorEntry;
+/** Проверяет полный recursive discriminated menu contract без coercion/fallback. / Validates the complete recursive discriminated menu contract without coercion/fallback. */
+export declare function validateSMenuEntries(value: unknown): asserts value is readonly SMenuEntry[];
+export {};

package/dist/src/components/shared/controls/menu.js

@@ -0,0 +1,95 @@
+import { validateBoolean as e, validateExactString as t, validateNonEmptyString as n } from "../../../internal/runtimeContract.js";
+import { resolveLinkTarget as r } from "../../../internal/linkTarget.js";
+//#region src/components/shared/controls/menu.ts
+var i = [
+	"action",
+	"destination",
+	"checkbox",
+	"radio",
+	"separator",
+	"submenu"
+], a = ["row", "tile"], o = [
+	"secondary",
+	"success",
+	"info",
+	"warn",
+	"danger",
+	"contrast"
+], s = [
+	"kind",
+	"id",
+	"label",
+	"icon",
+	"disabled",
+	"shortcut",
+	"badge",
+	"badgeSeverity",
+	"layout"
+], c = {
+	action: ["current"],
+	destination: [
+		"href",
+		"to",
+		"target",
+		"rel",
+		"current"
+	],
+	checkbox: ["checked"],
+	radio: ["groupId", "checked"],
+	separator: [],
+	submenu: ["children"]
+};
+function l(e, t) {
+	if (typeof e != "object" || !e || Array.isArray(e)) throw TypeError(`SMenuSurface: ${t} must be an object`);
+}
+function u(t, n, r) {
+	t[n] !== void 0 && e("SMenuSurface", `${r}.${n}`, t[n]);
+}
+function d(e, t, r) {
+	e[t] !== void 0 && n("SMenuSurface", `${r}.${t}`, e[t]);
+}
+function f(e, r) {
+	if (n("SMenuSurface", `${r}.id`, e.id), n("SMenuSurface", `${r}.label`, e.label), u(e, "disabled", r), d(e, "shortcut", r), e.icon !== void 0 && typeof e.icon != "object" && typeof e.icon != "function") throw TypeError(`SMenuSurface: ${r}.icon must be a Vue component`);
+	if (e.badge !== void 0 && (typeof e.badge != "string" || e.badge.length === 0) && (typeof e.badge != "number" || !Number.isFinite(e.badge))) throw TypeError(`SMenuSurface: ${r}.badge must be a non-empty string or finite number`);
+	e.badgeSeverity !== void 0 && t("SMenuSurface", `${r}.badgeSeverity`, e.badgeSeverity, o), e.layout !== void 0 && t("SMenuSurface", `${r}.layout`, e.layout, a);
+}
+function p(e, t, n) {
+	let r = new Set(t === "separator" ? ["kind", "id"] : [...s, ...c[t]]);
+	for (let t of Object.keys(e)) if (!r.has(t)) throw TypeError(`SMenuSurface: ${n} has unsupported field '${t}'`);
+}
+function m(a, o, s) {
+	if (!Array.isArray(a)) throw TypeError(`SMenuSurface: ${o} must be an array`);
+	if (o !== "items" && a.length === 0) throw TypeError(`SMenuSurface: ${o} children must be a non-empty array`);
+	let c = /* @__PURE__ */ new Set(), d = !1;
+	for (let [h, g] of a.entries()) {
+		let _ = `${o}[${h}]`;
+		l(g, _);
+		let v = t("SMenuSurface", `${_}.kind`, g.kind, i);
+		p(g, v, _);
+		let y = n("SMenuSurface", `${_}.id`, g.id);
+		if (s.has(y)) throw TypeError(`SMenuSurface: duplicate entry id '${y}'`);
+		if (s.add(y), v === "separator") {
+			if (h === 0 || h === a.length - 1 || d) throw TypeError("SMenuSurface: separator cannot be first, last, or consecutive");
+			d = !0;
+			continue;
+		}
+		if (d = !1, f(g, _), (v === "action" || v === "destination") && u(g, "current", _), v === "destination" && r({
+			owner: `SMenuSurface: ${_}`,
+			href: g.href,
+			to: g.to,
+			target: g.target,
+			rel: g.rel
+		}), v === "checkbox" && g.checked !== "mixed" && typeof g.checked != "boolean") throw TypeError(`SMenuSurface: ${_}.checked must be a boolean or "mixed"`);
+		if (v === "radio") {
+			let t = n("SMenuSurface", `${_}.groupId`, g.groupId), r = e("SMenuSurface", `${_}.checked`, g.checked);
+			if (r && c.has(t)) throw TypeError(`SMenuSurface: radio group '${t}' has more than one checked entry`);
+			r && c.add(t);
+		}
+		v === "submenu" && m(g.children, `${_}.children`, s);
+	}
+}
+function h(e) {
+	m(e, "items", /* @__PURE__ */ new Set());
+}
+//#endregion
+export { h as validateSMenuEntries };

package/dist/src/components/shared/data-display/SActionCard.vue.d.ts

@@ -0,0 +1,37 @@
+import { VNodeChild } from 'vue';
+import { InteractiveSurfaceActionsLayout, InteractiveSurfaceContract, InteractiveSurfaceDensity, InteractiveSurfaceFill, InteractiveSurfacePadding, InteractiveSurfaceRadius, InteractiveSurfaceTone } from '../controls/SInteractiveSurface.vue';
+export interface Props {
+    surface: InteractiveSurfaceContract;
+    selected?: boolean;
+    tone?: InteractiveSurfaceTone;
+    density?: InteractiveSurfaceDensity;
+    padding?: InteractiveSurfacePadding;
+    radius?: InteractiveSurfaceRadius;
+    fill?: InteractiveSurfaceFill;
+    actionsLayout?: InteractiveSurfaceActionsLayout;
+}
+type __VLS_Slots = {
+    default?: () => VNodeChild;
+    actions?: () => VNodeChild;
+};
+declare const __VLS_base: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    activate: (event: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onActivate?: ((event: MouseEvent) => any) | undefined;
+}>, {
+    selected: boolean;
+    fill: InteractiveSurfaceFill;
+    radius: InteractiveSurfaceRadius;
+    tone: InteractiveSurfaceTone;
+    density: InteractiveSurfaceDensity;
+    actionsLayout: InteractiveSurfaceActionsLayout;
+    padding: InteractiveSurfacePadding;
+}, {}, {}, {}, 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/src/components/shared/data-display/SActionCard.vue.js

@@ -0,0 +1,8 @@
+import "../../../../assets/src/components/shared/data-display/SActionCard.css_vue_type_style_index_0_src_9c1a2409_scoped_9c1a2409_lang.css";
+import e from "../../../../_virtual/_plugin-vue_export-helper.js";
+import t from "./SActionCard.vue_vue_type_script_setup_true_lang.js";
+/* empty css                                                                         */
+//#region src/components/shared/data-display/SActionCard.vue
+var n = /*#__PURE__*/ e(t, [["__scopeId", "data-v-9c1a2409"]]);
+//#endregion
+export { n as default };

package/dist/src/components/shared/data-display/SActionCard.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,68 @@
+import { useOwnedAttrs as e } from "../../../internal/ownedAttrs.js";
+import t from "../controls/SInteractiveSurface.vue.js";
+import { createElementBlock as n, createElementVNode as r, createSlots as i, createVNode as a, defineComponent as o, mergeProps as s, openBlock as c, renderSlot as l, unref as u, withCtx as d } from "vue";
+//#region src/components/shared/data-display/SActionCard.vue?vue&type=script&setup=true&lang.ts
+var f = [
+	"data-has-actions",
+	"data-fill",
+	"data-mode",
+	"data-actions-layout"
+], p = { class: "s-action-card__content" }, m = { class: "s-action-card__actions" }, h = /*@__PURE__*/ o({
+	inheritAttrs: !1,
+	__name: "SActionCard",
+	props: {
+		surface: {},
+		selected: {
+			type: Boolean,
+			default: !1
+		},
+		tone: { default: "default" },
+		density: { default: "comfortable" },
+		padding: { default: "md" },
+		radius: { default: "lg" },
+		fill: { default: "content" },
+		actionsLayout: { default: "inline" }
+	},
+	emits: ["activate"],
+	setup(o, { emit: h }) {
+		let g = h, _ = e({
+			component: "SActionCard",
+			owner: "action card root"
+		});
+		return (e, h) => (c(), n("div", s(u(_).bindings(), {
+			class: "s-action-card",
+			"data-has-actions": !!e.$slots.actions || void 0,
+			"data-fill": o.fill,
+			"data-mode": o.surface.mode,
+			"data-actions-layout": o.actionsLayout
+		}), [a(t, {
+			surface: o.surface,
+			selected: o.selected,
+			tone: o.tone,
+			density: o.density,
+			padding: o.padding,
+			radius: o.radius,
+			fill: o.fill,
+			"actions-layout": o.actionsLayout,
+			onActivate: h[0] ||= (e) => g("activate", e)
+		}, i({
+			default: d(() => [r("div", p, [l(e.$slots, "default", {}, void 0, !0)])]),
+			_: 2
+		}, [e.$slots.actions ? {
+			name: "actions",
+			fn: d(() => [r("div", m, [l(e.$slots, "actions", {}, void 0, !0)])]),
+			key: "0"
+		} : void 0]), 1032, [
+			"surface",
+			"selected",
+			"tone",
+			"density",
+			"padding",
+			"radius",
+			"fill",
+			"actions-layout"
+		])], 16, f));
+	}
+});
+//#endregion
+export { h as default };

package/dist/src/components/shared/data-display/SActionList.vue.d.ts

@@ -0,0 +1,22 @@
+import { ScrollableViewportMaxBlockSize } from '../../../internal/semanticSizing';
+type __VLS_Props = {
+    accessibleLabel: string;
+    maxHeight?: ScrollableViewportMaxBlockSize;
+    surface?: 'bordered' | 'plain';
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    maxHeight: ScrollableViewportMaxBlockSize;
+    surface: "bordered" | "plain";
+}, {}, {}, {}, 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/src/components/shared/data-display/SActionList.vue.js

@@ -0,0 +1,8 @@
+import "../../../../assets/src/components/shared/data-display/SActionList.css_vue_type_style_index_0_src_5d4ca97f_scoped_5d4ca97f_lang.css";
+import e from "../../../../_virtual/_plugin-vue_export-helper.js";
+import t from "./SActionList.vue_vue_type_script_setup_true_lang.js";
+/* empty css                                                                         */
+//#region src/components/shared/data-display/SActionList.vue
+var n = /*#__PURE__*/ e(t, [["__scopeId", "data-v-5d4ca97f"]]);
+//#endregion
+export { n as default };

package/dist/src/components/shared/data-display/SActionList.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,32 @@
+import { useOwnedAttrs as e } from "../../../internal/ownedAttrs.js";
+import { validateScrollableViewportMaxBlockSize as t } from "../../../internal/semanticSizing.js";
+import { computed as n, createElementBlock as r, defineComponent as i, mergeProps as a, openBlock as o, renderSlot as s, unref as c } from "vue";
+//#region src/components/shared/data-display/SActionList.vue?vue&type=script&setup=true&lang.ts
+var l = [
+	"data-max-height",
+	"data-surface",
+	"aria-label"
+], u = /*@__PURE__*/ i({
+	inheritAttrs: !1,
+	__name: "SActionList",
+	props: {
+		accessibleLabel: {},
+		maxHeight: { default: "none" },
+		surface: { default: "bordered" }
+	},
+	setup(i) {
+		let u = i, d = e({
+			component: "SActionList",
+			owner: "action list root"
+		}), f = n(() => t("SActionList", "maxHeight", u.maxHeight));
+		return (e, t) => (o(), r("div", a(c(d).bindings(), {
+			class: "s-action-list",
+			"data-max-height": f.value,
+			"data-surface": i.surface,
+			role: "list",
+			"aria-label": i.accessibleLabel
+		}), [s(e.$slots, "default", {}, void 0, !0)], 16, l));
+	}
+});
+//#endregion
+export { u as default };

package/dist/src/components/shared/data-display/SActionListItem.vue.d.ts

@@ -0,0 +1,89 @@
+import { Component, VNodeChild } from 'vue';
+import { BadgeSeverity } from './SBadge.vue';
+import { Props as ButtonProps } from '../controls/SButton.vue';
+import { InteractiveSurfaceContract, InteractiveSurfaceDensity, InteractiveSurfacePadding, InteractiveSurfaceRadius, InteractiveSurfaceTone } from '../controls/SInteractiveSurface.vue';
+export interface ActionListItemBadge {
+    readonly id: string;
+    readonly label: string;
+    readonly severity: BadgeSeverity;
+}
+export interface ActionListItemActionsSlotProps {
+    readonly disabled: boolean;
+    readonly emitAction: (event: MouseEvent) => void;
+}
+type __VLS_Props = {
+    title: string;
+    titleTooltip?: string;
+    description?: string | null;
+    detail?: string | null;
+    icon?: Component;
+    surface?: InteractiveSurfaceContract;
+    indentLevel?: number;
+    selected?: boolean;
+    tone?: InteractiveSurfaceTone;
+    density?: InteractiveSurfaceDensity;
+    surfacePadding?: InteractiveSurfacePadding;
+    surfaceRadius?: InteractiveSurfaceRadius;
+    actionLabel?: string;
+    actionIcon?: Component;
+    actionSeverity?: ButtonProps['severity'];
+    actionDisabled?: boolean;
+    statusLabel?: string | null;
+    statusSeverity?: BadgeSeverity;
+    badges?: readonly ActionListItemBadge[];
+    trailingIcon?: Component;
+    trailingLayout?: 'responsive' | 'inline' | 'stacked';
+    heightMode?: 'content' | 'fill';
+    titlePresentation?: 'text' | 'code';
+    titleWeight?: 'regular' | 'semibold';
+    detailPresentation?: 'text' | 'code';
+    detailOverflow?: 'clamp-2' | 'wrap';
+};
+type __VLS_Slots = {
+    title?: () => VNodeChild;
+    description?: () => VNodeChild;
+    detail?: () => VNodeChild;
+    status?: () => VNodeChild;
+    actions?: (props: ActionListItemActionsSlotProps) => VNodeChild;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    action: (event: MouseEvent) => any;
+    activate: (event: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onAction?: ((event: MouseEvent) => any) | undefined;
+    onActivate?: ((event: MouseEvent) => any) | undefined;
+}>, {
+    selected: boolean;
+    icon: Component;
+    tone: InteractiveSurfaceTone;
+    trailingIcon: Component;
+    density: InteractiveSurfaceDensity;
+    detail: string | null;
+    description: string | null;
+    surface: InteractiveSurfaceContract;
+    titleTooltip: string;
+    indentLevel: number;
+    surfacePadding: InteractiveSurfacePadding;
+    surfaceRadius: InteractiveSurfaceRadius;
+    actionLabel: string;
+    actionIcon: Component;
+    actionSeverity: import('../controls/SButton.vue').SButtonSeverity;
+    actionDisabled: boolean;
+    statusLabel: string | null;
+    statusSeverity: BadgeSeverity;
+    badges: readonly ActionListItemBadge[];
+    trailingLayout: "responsive" | "inline" | "stacked";
+    heightMode: "content" | "fill";
+    titlePresentation: "text" | "code";
+    titleWeight: "regular" | "semibold";
+    detailPresentation: "text" | "code";
+    detailOverflow: "clamp-2" | "wrap";
+}, {}, {}, {}, 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/src/components/shared/data-display/SActionListItem.vue.js

@@ -0,0 +1,8 @@
+import "../../../../assets/src/components/shared/data-display/SActionListItem.css_vue_type_style_index_0_src_f0c4206a_scoped_f0c4206a_lang.css";
+import e from "../../../../_virtual/_plugin-vue_export-helper.js";
+import t from "./SActionListItem.vue_vue_type_script_setup_true_lang.js";
+/* empty css                                                                             */
+//#region src/components/shared/data-display/SActionListItem.vue
+var n = /*#__PURE__*/ e(t, [["__scopeId", "data-v-f0c4206a"]]);
+//#endregion
+export { n as default };