@bluepic/embed 0.4.0-next.99 → 0.5.0

package/dist/components/AssetViewer/AssetViewer.vue.d.ts

@@ -0,0 +1,71 @@
+import { type AssetAuth } from '../../util/assetAuth';
+/**
+ * Brand Portal — the asset viewer.
+ *
+ * Renders inside the existing overlay API (usePopup / injectPortal), the same
+ * surface as the image cropper, rather than sending the visitor to a browser
+ * tab.
+ *
+ * Efficiency rules that are load-bearing, not polish:
+ *  - page rendering is INJECTED by the host (`renderPage`) rather than importing
+ *    @bluepic/raster here. Embed ships a UMD build, and raster's root entry
+ *    carries CommonJS interop that Rollup cannot express in UMD (it emits an
+ *    invalid `var main.commonjsGlobal`). Injection also keeps the heavy engines
+ *    out of embed entirely — the host loads them only if it has documents.
+ *    Without a `renderPage`, paged types degrade to the download-only panel;
+ *  - one page is rendered at a time, at a DPR clamped to 2;
+ *  - at most PAGE_CACHE_LIMIT rendered pages are retained, so a 400-page PDF
+ *    cannot hold 400 canvases;
+ *  - in-flight work is abandoned on close/page-change — an orphaned
+ *    Ghostscript-WASM job otherwise keeps a phone warm long after the user left.
+ */
+export type ViewerAsset = {
+    id: string;
+    title: string;
+    filename: string;
+    mime: string;
+    size: number;
+    kind: 'image' | 'file';
+    previewUrl: string | null;
+    description?: string | null;
+    width?: number;
+    height?: number;
+    pageCount?: number;
+    /** Gated URL. Used both to fetch bytes for rasterization and to display media. */
+    downloadUrl: string;
+    /**
+     * A paginated, browser-renderable form: the file for a PDF, the server-made
+     * PDF derivative for Office/ODF. Its presence is what turns a .docx into
+     * something with pages instead of a download button.
+     */
+    documentUrl?: string;
+};
+type __VLS_Props = {
+    asset: ViewerAsset;
+    /**
+     * Render one page of a document into the supplied canvas. Supplied by the
+     * host (bx-template passes @bluepic/raster). Absent → no paged preview.
+     */
+    renderPage?: (bytes: ArrayBuffer, canvas: HTMLCanvasElement, opts: {
+        page: number;
+        dpi: number;
+    }) => Promise<void>;
+    /** Page count for a paged document, when the host can determine it. */
+    getPageCount?: (bytes: ArrayBuffer) => Promise<number>;
+    /**
+     * Proof of access for a PROTECTED campaign — the password it was unlocked
+     * with and/or the signed-in visitor's access token. Every `fetch()` here
+     * sends it as headers; the media elements, which cannot, get it as query
+     * parameters (see `util/assetAuth`). Absent for a public campaign, which
+     * leaves every request exactly as it was.
+     */
+    assetAuth?: AssetAuth | null;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    close: () => any;
+    download: (asset: ViewerAsset) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: (() => any) | undefined;
+    onDownload?: ((asset: ViewerAsset) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/BxAudioPlayButton.vue.d.ts

@@ -0,0 +1,24 @@
+/**
+ * The round play/pause control that sits in the middle of an audio card, with
+ * its own progress ring.
+ *
+ * Lives in the embed so the studio library and the portal show the SAME control
+ * — the two surfaces render audio assets side by side in a user's mind, and a
+ * different affordance in each is how they drift apart.
+ */
+type __VLS_Props = {
+    playing?: boolean;
+    loading?: boolean;
+    /** 0–1. */
+    progress?: number;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    toggle: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onToggle?: (() => any) | undefined;
+}>, {
+    progress: number;
+    playing: boolean;
+    loading: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/BxCard.vue.d.ts

@@ -9,6 +9,38 @@ type __VLS_Props = {
     coverWidth?: string;
     hoverable?: boolean;
     dividers?: boolean;
+    /**
+     * Corner rounding. `none` is for cards that tile edge to edge, where a
+     * radius reads as a gap that is not there.
+     */
+    radius?: 'none' | 'sm' | 'md' | 'lg';
+    /**
+     * Stack the content slot with a gap. Without it the content is a plain
+     * block, which is why almost every caller re-declared
+     * `display:flex; flex-direction:column; gap:…` and, from there, went on to
+     * hand-roll the whole card.
+     */
+    contentGap?: 'none' | 'sm' | 'md' | 'lg';
+    /**
+     * Let the CONTENT scroll inside the card.
+     *
+     * The wrapper sits OUTSIDE the padding and the content carries it instead,
+     * so the scrollbar rail runs along the card's edge rather than floating in
+     * the middle of a 15px gutter — and the first line of content is not
+     * clipped against the top of the scrollport when it moves.
+     *
+     * Every caller that tried this from outside got it wrong the same way: a
+     * `max-height` on a `bx-scrollbar` is inert, because the scrollbar is
+     * `height: 100%` and the percentage resolves against an auto-height parent.
+     * Here the card gives it a definite height to fill.
+     */
+    scrollable?: boolean;
+    /**
+     * The cap the content scrolls within — any CSS length. Without one the card
+     * grows to its content and nothing scrolls, which is the right behaviour
+     * for a card that fits.
+     */
+    maxContentHeight?: string;
     state?: 'default' | 'success' | 'warning' | 'error' | 'info';
 };
 type __VLS_Slots = {
@@ -27,6 +59,9 @@ declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}
     bordered: boolean;
     hoverable: boolean;
     dividers: boolean;
+    radius: "none" | "sm" | "md" | "lg";
+    contentGap: "none" | "sm" | "md" | "lg";
+    scrollable: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
 export default _default;

package/dist/components/BxInput.vue.d.ts

@@ -27,7 +27,13 @@ type __VLS_Props = {
         noStyleLabel: Localized<string>;
         mixedStyleLabel: Localized<string>;
     };
+    /**
+     * Explicit CSS max-height for the (textarea/richtext) input. When omitted, a
+     * textarea auto-grows up to `maxRows` lines.
+     */
     maxHeight?: string;
+    /** Maximum number of visible lines a `textarea` grows to before it scrolls. */
+    maxRows?: number;
     minHeight?: string;
     readonly?: boolean;
     readonlyMessage?: string;
@@ -77,7 +83,7 @@ declare const __VLS_component: import("vue").DefineComponent<__VLS_PublicProps,
     ring: boolean;
     clearable: boolean;
     resizeable: boolean;
-    maxHeight: string;
+    maxRows: number;
     readonly: boolean;
     readonlyMessage: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/components/BxList.vue.d.ts

@@ -1,12 +1,21 @@
 import { VNode } from 'vue';
 type __VLS_Props = {
     divider?: boolean;
+    /** Outer border and rounding, so a list can stand on its own surface. */
+    bordered?: boolean;
+    /**
+     * `plain` is a run of rows. `card` gives every row its own surface with a
+     * gap between them, for lists whose items are objects rather than lines.
+     */
+    variant?: 'plain' | 'card';
 };
 type __VLS_Slots = {
     default: () => VNode[] | VNode;
 };
 declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    bordered: boolean;
     divider: boolean;
+    variant: "plain" | "card";
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
 export default _default;

package/dist/components/BxListItem.vue.d.ts

@@ -1,10 +1,22 @@
 import { VNode } from 'vue';
+type __VLS_Props = {
+    /**
+     * Whether clicking the row does something. Rows used to get a pointer
+     * cursor and a hover background unconditionally, which is why static lists
+     * were hand-rolled as <ul>s instead: a row that looks clickable and is not
+     * is worse than no component. Defaults to `true` so no existing list
+     * changes.
+     */
+    interactive?: boolean;
+};
 type __VLS_Slots = {
     default: () => VNode[] | VNode;
     prefix?: () => VNode[] | VNode;
     suffix?: () => VNode[] | VNode;
 };
-declare const __VLS_component: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    interactive: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
 export default _default;
 type __VLS_WithSlots<T, S> = T & {

package/dist/components/BxPopover.vue.d.ts

@@ -19,6 +19,12 @@ type __VLS_Props = {
     role?: string;
     killExistingRoleEntriesOnHoverShow?: boolean;
     maxPopoverHeight?: number;
+    /**
+     * Override the scroll pass-through decision. Defaults to "on whenever there
+     * is no darkened background", which is what makes a non-modal popover stop
+     * freezing the page behind it.
+     */
+    scrollPassthrough?: boolean;
 };
 type __VLS_Slots = {
     trigger: () => VNode[] | VNode;
@@ -39,6 +45,7 @@ declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {
     allowedPlacements: Placement[];
     arrow: boolean;
     overflowVisible: boolean;
+    scrollPassthrough: boolean;
     leaveLazyness: number;
     closeOnClickOutside: boolean;
     showLeazyness: number;

package/dist/components/BxPreviewLayer.vue.d.ts

@@ -0,0 +1,18 @@
+import { type AssetProxyConfig } from '../util/assetProxy';
+type __VLS_Props = {
+    /** The template's own committed preview (Cloudflare Images) — generic, shared by every viewer. */
+    basePreview?: string | null;
+    /**
+     * An individually pre-populated render (e.g. an `image.bluepic.io
+     * ?role=preview` URL). Pass this ONLY when prepopulation actually applies
+     * to what's being shown — omit it and this behaves like a plain
+     * single-image skeleton over `basePreview`.
+     */
+    personalizedSrc?: string | null;
+    assetProxy?: AssetProxyConfig;
+    alt?: string;
+    /** Width hint for `optimizePreviewUrl` on the base layer. */
+    baseWidth?: number;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/BxScrollbar.vue.d.ts

@@ -5,6 +5,12 @@ type __VLS_Props = {
     scrollDelay?: number;
     /** Delay in ms before the scrollbar fades out after mouse leaves */
     leaveDelay?: number;
+    /**
+     * Briefly reveal the rail the first time the content turns out to be
+     * scrollable. The rails are otherwise hover/scroll-only, which on a touch
+     * screen means a clipped list gives no cue at all that there is more.
+     */
+    hintScrollable?: boolean;
 };
 declare var __VLS_1: {};
 type __VLS_Slots = {} & {
@@ -18,6 +24,7 @@ declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {
     xScrollable: boolean;
     scrollDelay: number;
     leaveDelay: number;
+    hintScrollable: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
 export default _default;

package/dist/components/BxSelect.vue.d.ts

@@ -14,8 +14,22 @@ declare const _default: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>
     props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
         readonly "onUpdate:modelValue"?: ((value: T) => any) | undefined;
         readonly "onUpdate:show"?: ((value: boolean) => any) | undefined;
-    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onUpdate:modelValue" | "onUpdate:show"> & ({
+        readonly "onUpdate:values"?: ((values: T[]) => any) | undefined;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onUpdate:modelValue" | "onUpdate:show" | "onUpdate:values"> & ({
         modelValue?: T;
+        /**
+         * Multi-select: options toggle, the menu stays open, and the selection is
+         * carried by `values` (`v-model:values`) rather than `modelValue`.
+         *
+         * The selection deliberately lives in its OWN prop instead of overloading
+         * `modelValue` with `T | T[]`. Options may legitimately have array values
+         * (see StrokeDasharrayInput, where `T = number[]`), and a union there makes
+         * the generic ambiguous — it silently re-infers `T` and breaks unrelated
+         * callers. One extra prop is cheaper than that class of surprise.
+         */
+        multiple?: boolean;
+        /** Selected values when `multiple` is set. */
+        values?: T[];
         size?: "tiny" | "small" | "medium" | "large";
         trigger?: "click" | "hover" | "manual";
         options: BxSelectOption<T>[];
@@ -70,7 +84,7 @@ declare const _default: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>
             value?: T;
         }) => VNode[];
     };
-    emit: ((evt: "update:modelValue", value: T) => void) & ((evt: "update:show", value: boolean) => void);
+    emit: (((evt: "update:modelValue", value: T) => void) & ((evt: "update:values", values: T[]) => void)) & ((evt: "update:show", value: boolean) => void);
 }>) => import("vue").VNode & {
     __ctx?: Awaited<typeof __VLS_setup>;
 };

package/dist/components/BxTable.vue.d.ts

@@ -0,0 +1,109 @@
+import { VNode } from 'vue';
+export interface BxTableColumn {
+    /** Identity only; the caller writes the cells. */
+    key: string;
+    label: string;
+    align?: 'left' | 'center' | 'right';
+    width?: string;
+    /** Header text for assistive tech only, e.g. an actions column. */
+    srOnlyLabel?: boolean;
+    /** Class(es) put on the header cell — the caller puts the same on its `<td>`s. */
+    class?: string;
+    /**
+     * Pin the column while the table scrolls sideways. Pinned columns must be
+     * the outermost ones (the first N / the last N); anything else is ignored.
+     */
+    sticky?: 'left' | 'right';
+}
+/**
+ * A table's chrome: the scroll container, the border, the header, row hover,
+ * per-column alignment, pinned header/columns and row states.
+ *
+ * The BODY is a slot rather than a `rows` prop on purpose. Real tables wrap
+ * their rows — the studio's org list puts every `<tr>` inside a
+ * visibility-observer for infinite scroll — and a data-driven table cannot
+ * express that without growing a render-prop for the wrapper. So the caller
+ * keeps its `<tr>`s and this owns everything around them, which is the part
+ * that was being re-written per app.
+ *
+ * Alignment and pinning reach app-authored cells through custom properties
+ * rather than classes the caller would have to remember: each column publishes
+ * `--col-N-align` (and, when pinned, `--col-N-position/left/right/z`), and the
+ * static rules below read them. Twenty-four columns is the supported width.
+ *
+ * Row states are read off ATTRIBUTES on the caller's `<tr>`, so a table stays
+ * a table for assistive tech:
+ *   - `aria-current="true"`  → the ACTIVE row (themed inset ring)
+ *   - `aria-selected="true"` → a SELECTED row (soft primary background)
+ */
+type __VLS_Props = {
+    columns?: BxTableColumn[];
+    /** Outer border, so the table can sit on the page unwrapped. */
+    bordered?: boolean;
+    /** Corner rounding, same scale as BxCard. */
+    radius?: 'none' | 'sm' | 'md' | 'lg';
+    /**
+     * `plain` is a table on the page's own ground. `card` puts it on a raised
+     * surface, for a table that reads as a block of its own rather than a
+     * region of the page. (Note this differs from BxList's `card`, where each
+     * ROW is a surface; a table's rows cannot be separated without breaking
+     * column alignment, which is the whole point of a table.)
+     */
+    variant?: 'plain' | 'card';
+    /** Row highlight on hover. Off unless rows actually do something. */
+    hoverable?: boolean;
+    dense?: boolean;
+    /** Keep the header row visible while the body scrolls vertically. */
+    stickyHeader?: boolean;
+    /**
+     * Fill the parent (a flex column) and scroll INSIDE the wrapper in both
+     * axes, instead of growing with the rows. Momentum scrolling and contained
+     * overscroll come with it, so the page never scrolls sideways.
+     */
+    fill?: boolean;
+    /** Cap the wrapper's height; the body scrolls beyond it. */
+    maxHeight?: string;
+    /**
+     * Pin the first `left` / last `right` columns while scrolling sideways.
+     * The per-column `sticky` field is the other way to say the same thing.
+     */
+    stickyColumns?: {
+        left?: number;
+        right?: number;
+    };
+};
+type __VLS_Slots = {
+    default?: () => VNode[] | VNode;
+    /** Replaces a header cell's label; the column def and its index come along. */
+    'header-cell'?: (scope: {
+        column: BxTableColumn;
+        index: number;
+    }) => VNode[] | VNode;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {
+    /** The outer box — query rows from here (`scrollIntoView` finds the scroller itself). */
+    wrapperRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+    /** BxScrollbar's inner container: the element that actually scrolls. */
+    scrollEl: import("vue").ComputedRef<HTMLElement | undefined>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    fill: boolean;
+    bordered: boolean;
+    hoverable: boolean;
+    radius: "none" | "sm" | "md" | "lg";
+    maxHeight: string;
+    variant: "plain" | "card";
+    columns: BxTableColumn[];
+    dense: boolean;
+    stickyHeader: boolean;
+    stickyColumns: {
+        left?: number;
+        right?: number;
+    };
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/BxTabs.vue.d.ts

@@ -4,6 +4,13 @@ type __VLS_Props = {
         name: string;
         label?: string;
         icon?: () => VNode[] | VNode;
+        /**
+         * Rendered AFTER the label — a count, a status dot. Separate from `icon`
+         * because it trails the name rather than introducing it, and because a
+         * tab that carries a number wants that number to read as part of the tab
+         * rather than as a second word in its name.
+         */
+        suffix?: () => VNode[] | VNode;
     }[];
     secondary?: boolean;
     size?: 'tiny' | 'small' | 'medium' | 'large';

package/dist/components/BxWaveformThumb.vue.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The generated waveform of an audio asset, painted in the CURRENT THEME's ink.
+ *
+ * bx-files renders an audio thumbnail as white bars on transparency (see
+ * `audioToPng`), which is only half a decision: it makes the image take the
+ * card's background, but it also makes it INVISIBLE on any light surface —
+ * white bars on a white card. Since a portal's theme is the customer's choice
+ * and half the presets are light, "white" is not a colour a waveform can be.
+ *
+ * The fix is to stop treating the PNG as a picture and treat it as a SHAPE: its
+ * alpha channel is the waveform, so it is used as a mask over `currentColor`.
+ * The bars then inherit whatever ink the surrounding text uses, in every theme,
+ * with no second asset, no server round-trip and no re-render of files already
+ * uploaded.
+ *
+ * Lives in the embed, next to `BxAudioPlayButton`, for the same reason: the
+ * studio library and the portal show the same audio card, and a treatment that
+ * exists in only one of them is how the two drift apart.
+ */
+type __VLS_Props = {
+    /** URL of the generated waveform PNG (white-on-transparent). */
+    src: string;
+    /** Accessible name — normally the asset's title. */
+    alt?: string;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/CollectionFieldPopup.vue.d.ts

@@ -10,8 +10,12 @@ declare const _default: <T extends {
         description?: string;
         detailedDescription?: string;
         bridge: FieldsBridge;
+        defaultObject?: T;
+        /** @deprecated old prop name for `defaultObject`. */
         defaultValue?: T;
         mobile?: boolean;
+        min?: number;
+        max?: number;
     } & {
         modelValue: T[];
     }) & Partial<{}>> & import("vue").PublicProps;

package/dist/components/PopoverElement.vue.d.ts

@@ -12,12 +12,20 @@ type __VLS_Props = {
     bxPopoverId: string;
     noPointerEvents: boolean;
     overflowVisible: boolean;
+    /**
+     * Let wheel/touch gestures that land beside the popover scroll the app
+     * behind it. Set for popovers opened WITHOUT a scrim — with one, freezing
+     * the page is the intended modal behaviour. See useScrollPassthrough.
+     */
+    scrollPassthrough?: boolean;
     capturedContext?: Record<string | symbol, any>;
     popoverMaxHeight?: string;
 };
-declare var __VLS_1: {};
+declare var __VLS_1: {}, __VLS_6: {};
 type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_1) => any;
+} & {
+    default?: (props: typeof __VLS_6) => any;
 };
 declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     close: () => any;
@@ -33,6 +41,7 @@ declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}
     capturedContext: Record<string | symbol, any>;
     floatingPadding: number;
     noPointerEvents: boolean;
+    scrollPassthrough: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
 export default _default;

package/dist/components/TemplateEditor/BatchCell.vue.d.ts

@@ -0,0 +1,18 @@
+import type { BluepicField } from '@bluepic/types';
+type __VLS_Props = {
+    field: BluepicField;
+    /** The row's data object — mutated in place. */
+    data: Record<string, unknown>;
+    labelId?: string;
+    /** Header bulk control: route every write through `onBulkUpdate` instead. */
+    bulk?: boolean;
+    onBulkUpdate?: (bindingKey: string, value: unknown) => void;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (bindingKey: string, value: unknown) => any;
+    activate: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onChange?: ((bindingKey: string, value: unknown) => any) | undefined;
+    onActivate?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;