@mittwald/flow-remote-vue-components 0.0.0-stage → 1.5.0

package/dist/types/index.d.ts

@@ -0,0 +1,25 @@
+export * from './auto-generated';
+export * from './icons';
+export * from './components/Action';
+export * from './components/ActionBatch';
+export * from './components/BrowserOnly';
+export * from './components/CountryOptions';
+export * from './components/DeprecationWarningProvider';
+export * from './components/Form';
+export * from './components/LoadingIndicator';
+export * from './list';
+export * from './components/NotificationProvider';
+export * from './components/RemoteRoot';
+export * from './components/SettingsProvider';
+export * from './components/Wrap';
+export * from './overlays/LightBox';
+export * from './overlays/Modal';
+export * from './overlays/Popover';
+export * from './overlays/triggers';
+export { createOverlayController, injectOverlayController, useModalController, useOverlayController, type OverlayController, type CreateOverlayControllerOptions, type OverlayCloseOptions, type UseOverlayControllerOptions, } from './overlays/overlayController';
+export { useIsMounted } from './composables/useIsMounted';
+export { useOnChange } from './composables/useOnChange';
+export { useLanguage, useRemoteConnection, type RemoteContext, } from './composables/remoteContext';
+export { createFlowRemoteComponent, type CreateFlowRemoteComponentOptions, } from './lib/createFlowRemoteComponent';
+export type { FlowRemoteVueComponent, RemoteVueProps, RemoteVueSlots, } from './lib/types';
+export { communicationVersion, packageVersion } from './version';

package/dist/types/lib/composition.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Marks one of this package's own components — a composition such as `Modal` or
+ * `List`, or the root. The elements it creates are its implementation, not the
+ * extension's.
+ */
+export declare const composition: <T extends object>(component: T) => T;
+/**
+ * Whether the calling component was created by a composition rather than by the
+ * extension.
+ *
+ * Vue records on every vnode the instance whose render created it (`ctx`),
+ * `cloneVNode` keeps it, and a slot runs with the context of whoever wrote it.
+ * An extension's `<Heading>` inside a `<Modal>` therefore belongs to the
+ * extension, and the `OverlayContent` the `Modal` renders around it belongs to
+ * the `Modal` — the line Flow's React views draw with `markViewComponents`.
+ */
+export declare const isRenderedByComposition: () => boolean;

package/dist/types/lib/controlledRemoteValue.d.ts

@@ -0,0 +1,30 @@
+import { AnyRecord } from './types';
+/**
+ * Keeps a controlled field's caret from jumping.
+ *
+ * A remote field reports every keystroke to the app, which writes the value
+ * back. That round trip is a full frame late, so a plain write would reset the
+ * host input to a value the user has already typed past. The marker tells the
+ * host "unchanged", so it leaves its own state alone.
+ *
+ * The React version has to ask `eventHandlerContext` whether the current
+ * `onChange` came from a remote event, because a local Flow component in the
+ * same tree calls the same handler. Here every listener call comes from the
+ * element, so the remote origin is given.
+ */
+export declare const controlledRemoteValue: (tag: string) => {
+    mapProperties: (properties: AnyRecord) => AnyRecord;
+    /**
+     * What a `v-model` modifier made of the reported value — `.trim` turns
+     * `"Ellen "` into `"Ellen"`. Written back, that is still the echo of what
+     * the field shows, and applying it would take the space the user just
+     * typed; Vue's own `<input v-model.trim>` leaves the input alone for the
+     * same reason.
+     */
+    recordModelledValue: (value: unknown) => void;
+    /**
+     * `FlowRemoteElement` hands a listener the event's `detail`, so a `change`
+     * listener is called with the new value itself.
+     */
+    recordEventPayload: (event: string, payload: unknown) => void;
+};

package/dist/types/lib/createFlowRemoteComponent.d.ts

@@ -0,0 +1,29 @@
+import { AnyRecord, FlowRemoteVueComponent, PropertiesOf } from './types';
+import { RemoteElementConstructor } from '@mittwald/flow-remote-core';
+export interface CreateFlowRemoteComponentOptions<SlotName extends readonly string[]> {
+    /**
+     * The component's slot props (`ReactNode`-typed props of the Flow component).
+     * They are passed as named Vue slots and travel as slotted children, never as
+     * remote properties — a rendered subtree does not survive structured clone.
+     */
+    slots?: SlotName;
+    /**
+     * The component's boolean props. A bare attribute (`<TextField is-required>`)
+     * reaches the wrapper as `""`, which is falsy on the host; these are read as
+     * `true` instead, the way Vue casts a declared `Boolean`.
+     */
+    booleans?: readonly string[];
+}
+/**
+ * Wraps a `flr-*` remote element in a Vue component.
+ *
+ * Everything the wrapper needs at runtime — which keys are remote properties,
+ * which are events, which are slots — is already on the element class
+ * (`remotePropertyDefinitions`, `remoteEventDefinitions`,
+ * `remoteSlotDefinitions`). So unlike the React counterpart, which has the
+ * generator write an `eventProps` map into every generated file, this factory
+ * reads the element's own metadata. What a generated file still names is what
+ * the element cannot tell at runtime: its slots and its boolean props.
+ */
+export declare function createFlowRemoteComponent<ElementConstructor extends RemoteElementConstructor<AnyRecord, AnyRecord, AnyRecord, AnyRecord>, const SlotNames extends readonly string[] = []>(tag: string, name: string, Element: ElementConstructor, options?: CreateFlowRemoteComponentOptions<SlotNames>): FlowRemoteVueComponent<PropertiesOf<ElementConstructor>, SlotNames[number]>;
+export default createFlowRemoteComponent;

package/dist/types/lib/handlers.d.ts

@@ -0,0 +1,25 @@
+export type AnyHandler = Function;
+/** Whether a prop key is an event handler (`onPress`, `onOpenChange`). */
+export declare const isHandlerKey: (key: string) => boolean;
+/**
+ * Every function in a handler value. Vue's `mergeProps` — and so `cloneVNode` —
+ * combines two handlers for one key into an array, and nests them when it
+ * merges again.
+ */
+export declare const flattenHandlers: (value: unknown) => AnyHandler[];
+/** Calls every handler in `value` with the same arguments, in order. */
+export declare const callHandlers: (value: unknown, ...args: unknown[]) => void;
+export type EventModifier = "once" | "passive" | "capture";
+export interface EventKey {
+    event: string;
+    modifiers: ReadonlySet<EventModifier>;
+}
+/**
+ * The element event a v-on key listens to, and the modifiers Vue folded into
+ * it: `@press.once` compiles to `onPressOnce`, `@click.capture.once` to
+ * `onClickCaptureOnce` — `Once`, `Passive` and `Capture` in template order. An
+ * exact event name wins, so React's own capture events (`clickCapture`) keep
+ * their meaning, and `.capture` resolves to one where the element has it.
+ * `undefined` when the key names no event of the element.
+ */
+export declare const resolveEventKey: (key: string, events: ReadonlyMap<string, unknown>) => EventKey | undefined;

package/dist/types/lib/isRenderError.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Whether Vue's `onErrorCaptured` info names a render or setup error — what
+ * React's error boundary catches. Vue names the source in development and links
+ * its error code in production (`…/error-reference/#runtime-1`).
+ */
+export declare const isRenderError: (info: string) => boolean;

package/dist/types/lib/mobxSelector.d.ts

@@ -0,0 +1,14 @@
+import { Ref } from 'vue';
+/**
+ * Reads a MobX value as a Vue ref.
+ *
+ * The counterpart of `useSelector` in `@mittwald/flow-react-components`: the
+ * state in `@mittwald/flow-components-base` is MobX and knows no framework, so
+ * each binding brings its own subscription. This is that subscription, and it
+ * is the whole of it — twelve lines against a shared model.
+ *
+ * `shallowRef`, because what MobX hands back is already the value to render;
+ * making Vue walk into it would only cost a proxy and could fight MobX's own.
+ */
+export declare const watchMobxValue: <T>(select: () => T) => Readonly<Ref<T>>;
+export default watchMobxValue;

package/dist/types/lib/propKeys.d.ts

@@ -0,0 +1,17 @@
+/** `isRequired` → `is-required`, the way Vue's own `hyphenate` spells it. */
+export declare const hyphenate: (key: string) => string;
+/**
+ * A prop off a vnode, whichever way the template spelled it. A vnode carries
+ * its props as written; Vue camelizes only when it resolves the props of the
+ * component itself.
+ */
+export declare const readProp: (props: Record<string, unknown> | null | undefined, key: string) => unknown;
+/**
+ * Props off a vnode, normalized the way Vue normalizes the props a component
+ * declares: keys camelized (except `aria-*`/`data-*`), and a bare attribute
+ * read as `true` where the key is a boolean. For components that read another
+ * component's vnode instead of receiving the props themselves.
+ */
+export declare const normalizeVNodeProps: (props: Record<string, unknown> | null | undefined, booleanKeys?: readonly string[]) => Record<string, unknown>;
+/** A boolean prop off a vnode, whichever way the template spelled it. */
+export declare const readBooleanProp: (props: Record<string, unknown> | null | undefined, key: string) => unknown;

package/dist/types/lib/stringifyError.d.ts

@@ -0,0 +1 @@
+export declare const stringifyError: (error: unknown) => string;

package/dist/types/lib/types.d.ts

@@ -0,0 +1,72 @@
+import { RemoteElement } from '@mittwald/flow-remote-core';
+import { Slot, VNodeProps } from 'vue';
+import { defaultModelProperties, modelEventAliases } from './vModel';
+export type AnyRecord = Record<string, any>;
+/**
+ * Props a React component takes that have no counterpart on a Vue component.
+ * `children` and the slot props become Vue slots, `ref`/`key` are Vue's own.
+ */
+type NonVueProps = "children" | "ref" | "key";
+/**
+ * The React props of a Flow component, as a Vue component sees them.
+ *
+ * Event props keep their React spelling (`onPress`, `onChange`, …) on purpose:
+ * that is exactly the key Vue's template compiler produces for `@press` /
+ * `@change`, so `emits` and the prop type stay one and the same declaration.
+ */
+export type RemoteVueProps<Props, SlotName extends string> = Partial<Omit<Props, NonVueProps | SlotName>> & ModelProps<Props> & {
+    /** Rendered by the host as the component's `className`. */
+    class?: string;
+};
+/**
+ * The props `v-model` can bind — the rule `src/lib/vModel.ts` applies at
+ * runtime, over the props type. A prop is controllable, which Flow spells with
+ * a `default*` sibling (`value`/`defaultValue`, `isOpen`/`defaultOpen` or
+ * `isDefaultOpen`), and the component has the event reporting it (`onChange`,
+ * `onOpenChange`, …).
+ */
+type ModelKey<Props> = {
+    [K in keyof Props & string]: [
+        Extract<DefaultSibling<K>, keyof Props>
+    ] extends [never] ? never : [Extract<`on${Capitalize<ModelEvent<K>>}`, keyof Props>] extends [never] ? never : K;
+}[keyof Props & string];
+/** `isOpen` → `Open`; nothing for a key that is not `is<Upper>…`. */
+type Flag<K extends string> = K extends `is${infer Rest}` ? Rest extends Uncapitalize<Rest> ? never : Rest : never;
+type DefaultSibling<K extends string> = `default${Capitalize<K>}` | `default${Flag<K>}` | `isDefault${Flag<K>}`;
+/** `isOpen` → `open`, `inputValue` → `input`, `selectedKeys` → `selected`. */
+type ModelBase<K extends string> = Uncapitalize<WithoutValueSuffix<[Flag<K>] extends [never] ? K : Flag<K>>>;
+type WithoutValueSuffix<K extends string> = K extends "value" ? "" : K extends `${infer Base}Value` ? Base : K extends `${infer Base}Keys` ? Base : K extends `${infer Base}Key` ? Base : K;
+type ModelEvent<K extends string> = (ModelBase<K> extends "" ? never : `${ModelBase<K>}Change`) | (ModelBase<K> extends keyof typeof modelEventAliases ? (typeof modelEventAliases)[ModelBase<K>][number] : never);
+/** What a bare `v-model` binds: the first of these the component has. */
+type DefaultModelKey<Props, Candidates extends readonly string[] = typeof defaultModelProperties> = Candidates extends readonly [
+    infer Head extends string,
+    ...infer Rest extends readonly string[]
+] ? Head extends ModelKey<Props> ? Head : DefaultModelKey<Props, Rest> : never;
+type Reported<Value> = Exclude<Value, undefined>;
+type ModelProps<Props> = {
+    [K in ModelKey<Props> as `onUpdate:${K}`]?: (value: Reported<Props[K]>) => void;
+} & ([DefaultModelKey<Props>] extends [never] ? unknown : {
+    modelValue?: Props[DefaultModelKey<Props> & keyof Props];
+    "onUpdate:modelValue"?: (value: Reported<Props[DefaultModelKey<Props> & keyof Props]>) => void;
+});
+export type RemoteVueSlots<SlotName extends string> = {
+    default?: Slot;
+} & Record<SlotName, Slot | undefined>;
+/**
+ * A Vue component wrapping a `flr-*` remote element.
+ *
+ * Typed through the constructor-signature form Vue's template type-checker
+ * understands, which is what makes `@press` / `:is-disabled` / `#emptyView`
+ * check against the Flow component's real props in an SFC.
+ */
+export type FlowRemoteVueComponent<Props, SlotName extends string = never> = new () => {
+    $props: VNodeProps & RemoteVueProps<Props, SlotName>;
+    $slots: RemoteVueSlots<SlotName>;
+};
+/**
+ * The Flow component's props, read off the remote element class — the same
+ * inference `@mittwald/remote-dom-react` uses, so both framework packages take
+ * their types from one source.
+ */
+export type PropertiesOf<ElementConstructor> = ElementConstructor extends new () => RemoteElement<infer Properties, AnyRecord, AnyRecord, AnyRecord> ? Properties : never;
+export {};

package/dist/types/lib/vModel.d.ts

@@ -0,0 +1,53 @@
+/**
+ * `v-model` on a remote component.
+ *
+ * Vue compiles `v-model="x"` on a component to `modelValue` plus
+ * `onUpdate:modelValue`, and `v-model:is-open="x"` to `is-open` plus
+ * `onUpdate:isOpen`. Neither is a key the element knows: the Flow component
+ * takes a prop and reports its change as an event of its own. So this maps both
+ * halves onto the pair the element has — `value` and `change`, `isOpen` and
+ * `openChange`, `selectedKey` and `selectionChange`.
+ *
+ * A prop can be bound when it is controllable, which Flow — like react-aria —
+ * spells as a `default*` sibling (`defaultValue`, `defaultOpen` or
+ * `isDefaultOpen` for `isOpen`), and when the element has the event that
+ * reports it. `ModelKey` in `src/lib/types.ts` is the same rule over the props
+ * type.
+ */
+export interface ModelBinding {
+    property: string;
+    event: string;
+}
+/** Tried in order for a bare `v-model`: the first the element has wins. */
+export declare const defaultModelProperties: readonly ["value", "isSelected", "selectedKey", "selectedKeys"];
+/**
+ * Events a prop reports through besides `<base>Change`, by base name — the prop
+ * without `is`, and without a trailing `Value`/`Key`/`Keys`.
+ */
+export declare const modelEventAliases: {
+    readonly "": readonly ["change"];
+    readonly selected: readonly ["selectionChange", "change"];
+    readonly focused: readonly ["focusChange"];
+};
+export declare const createModelResolver: (properties: ReadonlyMap<string, unknown>, events: ReadonlyMap<string, unknown>) => {
+    /**
+     * The binding for a `v-model` argument as the template wrote it —
+     * `modelValue` for a bare `v-model`, else the prop in either spelling.
+     */
+    resolve: (argument: string) => ModelBinding | undefined;
+};
+/** `onUpdate:isOpen` → `isOpen`. */
+export declare const modelUpdateArgument: (key: string) => string | undefined;
+/**
+ * The modifiers of a `v-model`, which Vue passes as a prop of their own:
+ * `modelModifiers`, or `<arg>Modifiers` in whichever spelling the template used
+ * — Vue's own `emit` looks up the same three.
+ */
+export declare const modelModifierKeys: (argument: string) => string[];
+export declare const isModelModifierKey: (key: string) => boolean;
+/**
+ * `.trim` and `.number`, which Vue's `emit` applies for a component that emits
+ * `update:*` itself. The element reports the value, not an emit, so they are
+ * applied here.
+ */
+export declare const applyModelModifiers: (value: unknown, modifiers: Record<string, unknown> | undefined) => unknown;

package/dist/types/list/ActiveFilters.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The selected filter values, and what can be done with the set of them.
+ *
+ * Shown beside the filter menus rather than inside them, so a selection made in
+ * one menu stays visible while another is open — and can be taken back one
+ * value at a time.
+ */
+export declare const ActiveFilters: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    isDisabled: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default ActiveFilters;

package/dist/types/list/AllFiltersModal.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Every filter, sorting and view mode in one off-canvas modal.
+ *
+ * The mobile path to what the header shows as separate menus on desktop — and
+ * on desktop too, where a list has secondary filters that the header leaves
+ * out. It drives the same model objects, so a value ticked here is the same
+ * event as one ticked in a menu.
+ */
+export declare const AllFiltersModal: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** The layouts this list can show, from the header. */
+    viewModes: {
+        type: () => ("list" | "table" | "tiles")[];
+        default: () => never[];
+    };
+}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** The layouts this list can show, from the header. */
+    viewModes: {
+        type: () => ("list" | "table" | "tiles")[];
+        default: () => never[];
+    };
+}>> & Readonly<{}>, {
+    isDisabled: boolean;
+    viewModes: ("table" | "list" | "tiles")[];
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default AllFiltersModal;

package/dist/types/list/ComposableLoader.d.ts

@@ -0,0 +1,23 @@
+/**
+ * One batch of a composable loader.
+ *
+ * A composable runs in `setup()` and nowhere else, so the list cannot call one
+ * from the watcher that drives its async loader. It renders one of these per
+ * batch instead — which is what React's `DataLoader` does with its hooks
+ * loader, one component per batch, each calling the consumer's hook.
+ *
+ * It renders nothing. What it contributes is a `setup()` for the consumer's
+ * composable and an effect that reports what the composable produced.
+ */
+export declare const ListComposableBatchLoader: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    batchIndex: {
+        type: NumberConstructor;
+        required: true;
+    };
+}>, () => null, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    batchIndex: {
+        type: NumberConstructor;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default ListComposableBatchLoader;

package/dist/types/list/Footer.d.ts

@@ -0,0 +1,5 @@
+/** How many items are shown, and the way to ask for more. */
+export declare const Footer: import('vue').DefineComponent<{}, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default Footer;

package/dist/types/list/Header.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The list's controls: layout, sorting, filters, search — plus the app's own
+ * `ActionGroup`, which the `List` hands over as the `actions` slot.
+ *
+ * Each one is a remote element the host materialises — a context menu trigger
+ * with a button and a menu — and what they act on is the shared model, so a
+ * filter behaves here exactly as it does in React.
+ */
+export declare const Header: import('vue').DefineComponent<{}, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default Header;

package/dist/types/list/Item.d.ts

@@ -0,0 +1,40 @@
+import { PropType } from 'vue';
+/**
+ * One item of the list.
+ *
+ * A component rather than a few lines in `Items`, because an expandable item
+ * holds state: each one is open or closed on its own, and a render function has
+ * nowhere to keep that.
+ */
+export declare const ListItemRow: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    itemId: {
+        type: StringConstructor;
+        required: true;
+    };
+    data: {
+        type: PropType<never>;
+        required: true;
+    };
+    isTile: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    itemId: {
+        type: StringConstructor;
+        required: true;
+    };
+    data: {
+        type: PropType<never>;
+        required: true;
+    };
+    isTile: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    isTile: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default ListItemRow;

package/dist/types/list/Items.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The list's items, as a grid list.
+ *
+ * The same element Flow's React list renders (`flr-items-grid-list`), so the
+ * host materialises the same component — layout, selection and keyboard
+ * behaviour included. What is rebuilt here is only which items go into it.
+ */
+export declare const Items: import('vue').DefineComponent<{}, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default Items;

package/dist/types/list/List.d.ts

@@ -0,0 +1,192 @@
+import { PropType, VNode } from 'vue';
+/**
+ * Flow's `List`, rebuilt in Vue.
+ *
+ * `List` is a React composition rather than a remote element, so there is
+ * nothing to generate — but everything it _decides_ now lives in
+ * `@mittwald/flow-components-base` and is shared with React. What is written
+ * here is the arrangement: which remote elements the host is asked for, and the
+ * one job the shared model leaves open, which is fetching a batch.
+ */
+export declare const List: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    /**
+     * The key the list's view settings are persisted under. Needs a surrounding
+     * `<SettingsProvider>`; without a key nothing is persisted.
+     */
+    settingStorageKey: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    /**
+     * Whether items can be selected, and how many.
+     *
+     * The host's grid list and table own the selection — these are handed
+     * straight through, the way Flow's React list hands them through.
+     */
+    selectionMode: {
+        type: PropType<"none" | "single" | "multiple">;
+        default: undefined;
+    };
+    /** Whether selecting replaces the selection or adds to it. */
+    selectionBehavior: {
+        type: PropType<"toggle" | "replace">;
+        default: undefined;
+    };
+    selectedKeys: {
+        type: PropType<"all" | readonly (string | number)[]>;
+        default: undefined;
+    };
+    defaultSelectedKeys: {
+        type: PropType<"all" | readonly (string | number)[]>;
+        default: undefined;
+    };
+    disabledKeys: {
+        type: PropType<readonly (string | number)[]>;
+        default: undefined;
+    };
+    disallowEmptySelection: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    onSelectionChange: {
+        type: PropType<(keys: unknown) => void>;
+        default: undefined;
+    };
+    /**
+     * Makes the items expandable. The expanded content is the item's `<Content
+     * slot="bottom">`.
+     */
+    accordion: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** How many items one batch holds. @default 20 */
+    batchSize: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    /** How many placeholders to show while the first batch loads. */
+    loadingItemsCount: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    /** A stable id per item, used to deduplicate across batches. */
+    getItemId: {
+        type: PropType<(data: never) => string>;
+        default: undefined;
+    };
+    /** The layout to start in. @default "list" */
+    defaultViewMode: {
+        type: PropType<"list" | "table" | "tiles">;
+        default: undefined;
+    };
+    /** Hides the pagination controls below the list. */
+    hidePagination: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    onAction: {
+        type: PropType<(data: never) => void>;
+        default: undefined;
+    };
+}>, () => VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    /**
+     * The key the list's view settings are persisted under. Needs a surrounding
+     * `<SettingsProvider>`; without a key nothing is persisted.
+     */
+    settingStorageKey: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    /**
+     * Whether items can be selected, and how many.
+     *
+     * The host's grid list and table own the selection — these are handed
+     * straight through, the way Flow's React list hands them through.
+     */
+    selectionMode: {
+        type: PropType<"none" | "single" | "multiple">;
+        default: undefined;
+    };
+    /** Whether selecting replaces the selection or adds to it. */
+    selectionBehavior: {
+        type: PropType<"toggle" | "replace">;
+        default: undefined;
+    };
+    selectedKeys: {
+        type: PropType<"all" | readonly (string | number)[]>;
+        default: undefined;
+    };
+    defaultSelectedKeys: {
+        type: PropType<"all" | readonly (string | number)[]>;
+        default: undefined;
+    };
+    disabledKeys: {
+        type: PropType<readonly (string | number)[]>;
+        default: undefined;
+    };
+    disallowEmptySelection: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    onSelectionChange: {
+        type: PropType<(keys: unknown) => void>;
+        default: undefined;
+    };
+    /**
+     * Makes the items expandable. The expanded content is the item's `<Content
+     * slot="bottom">`.
+     */
+    accordion: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** How many items one batch holds. @default 20 */
+    batchSize: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    /** How many placeholders to show while the first batch loads. */
+    loadingItemsCount: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    /** A stable id per item, used to deduplicate across batches. */
+    getItemId: {
+        type: PropType<(data: never) => string>;
+        default: undefined;
+    };
+    /** The layout to start in. @default "list" */
+    defaultViewMode: {
+        type: PropType<"list" | "table" | "tiles">;
+        default: undefined;
+    };
+    /** Hides the pagination controls below the list. */
+    hidePagination: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    onAction: {
+        type: PropType<(data: never) => void>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    selectedKeys: "all" | readonly (string | number)[];
+    defaultSelectedKeys: "all" | readonly (string | number)[];
+    disabledKeys: readonly (string | number)[];
+    selectionMode: "none" | "single" | "multiple";
+    disallowEmptySelection: boolean;
+    onSelectionChange: (keys: unknown) => void;
+    selectionBehavior: "replace" | "toggle";
+    onAction: (data: never) => void;
+    batchSize: number;
+    accordion: boolean;
+    loadingItemsCount: number;
+    getItemId: (data: never) => string;
+    defaultViewMode: "table" | "list" | "tiles";
+    settingStorageKey: string;
+    hidePagination: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default List;