@bluepic/embed 0.4.0-next.98 → 0.5.0

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;

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

@@ -0,0 +1,264 @@
+import { nextTick } from 'vue';
+import type { Template } from '@bluepic/types';
+import { type BxTableColumn } from '../BxTable.vue';
+import type { BatchRowsModel } from '../../util/batch/useBatchRows';
+/**
+ * The batch editor: a BxTable with one row per dataset and one column per
+ * field. Owns nothing but the table chrome — the rows live in `batch`
+ * (`useBatchRows`, created by BxTemplateEditor so the live preview and the
+ * export share the same model).
+ */
+type __VLS_Props = {
+    serial?: Template.Serial;
+    batch: BatchRowsModel;
+    /** The editor's resolved layout. Mobile drops the card chrome and goes full-bleed. */
+    layout?: 'mobile' | 'desktop';
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {
+    tableRef: import("vue").Ref<({
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly columns?: BxTableColumn[] | undefined;
+            readonly bordered?: boolean | undefined;
+            readonly radius?: "none" | "sm" | "md" | "lg" | undefined;
+            readonly variant?: "plain" | "card" | undefined;
+            readonly hoverable?: boolean | undefined;
+            readonly dense?: boolean | undefined;
+            readonly stickyHeader?: boolean | undefined;
+            readonly fill?: boolean | undefined;
+            readonly maxHeight?: string | undefined;
+            readonly stickyColumns?: {
+                left?: number;
+                right?: number;
+            } | undefined;
+        } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps;
+        $attrs: import("vue").Attrs;
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot<any> | undefined;
+        }>;
+        $root: import("vue").ComponentPublicInstance | null;
+        $parent: import("vue").ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<{
+            columns?: BxTableColumn[];
+            bordered?: boolean;
+            radius?: "none" | "sm" | "md" | "lg";
+            variant?: "plain" | "card";
+            hoverable?: boolean;
+            dense?: boolean;
+            stickyHeader?: boolean;
+            fill?: boolean;
+            maxHeight?: string;
+            stickyColumns?: {
+                left?: number;
+                right?: number;
+            };
+        }> & Readonly<{}>, {
+            wrapperRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+            scrollEl: import("vue").ComputedRef<HTMLElement | undefined>;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+            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").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
+    } & 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;
+        };
+    }> & Omit<Readonly<{
+        columns?: BxTableColumn[];
+        bordered?: boolean;
+        radius?: "none" | "sm" | "md" | "lg";
+        variant?: "plain" | "card";
+        hoverable?: boolean;
+        dense?: boolean;
+        stickyHeader?: boolean;
+        fill?: boolean;
+        maxHeight?: string;
+        stickyColumns?: {
+            left?: number;
+            right?: number;
+        };
+    }> & Readonly<{}>, "wrapperRef" | ("fill" | "bordered" | "hoverable" | "radius" | "maxHeight" | "variant" | "columns" | "dense" | "stickyHeader" | "stickyColumns") | "scrollEl"> & {
+        wrapperRef: HTMLDivElement | undefined;
+        scrollEl: HTMLElement | undefined;
+    } & {} & import("vue").ComponentCustomProperties & {} & {
+        $slots: {
+            default?: () => import("vue").VNode[] | import("vue").VNode;
+            'header-cell'?: (scope: {
+                column: BxTableColumn;
+                index: number;
+            }) => import("vue").VNode[] | import("vue").VNode;
+        };
+    }) | undefined, ({
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly columns?: BxTableColumn[] | undefined;
+            readonly bordered?: boolean | undefined;
+            readonly radius?: "none" | "sm" | "md" | "lg" | undefined;
+            readonly variant?: "plain" | "card" | undefined;
+            readonly hoverable?: boolean | undefined;
+            readonly dense?: boolean | undefined;
+            readonly stickyHeader?: boolean | undefined;
+            readonly fill?: boolean | undefined;
+            readonly maxHeight?: string | undefined;
+            readonly stickyColumns?: {
+                left?: number;
+                right?: number;
+            } | undefined;
+        } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps;
+        $attrs: import("vue").Attrs;
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot<any> | undefined;
+        }>;
+        $root: import("vue").ComponentPublicInstance | null;
+        $parent: import("vue").ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<{
+            columns?: BxTableColumn[];
+            bordered?: boolean;
+            radius?: "none" | "sm" | "md" | "lg";
+            variant?: "plain" | "card";
+            hoverable?: boolean;
+            dense?: boolean;
+            stickyHeader?: boolean;
+            fill?: boolean;
+            maxHeight?: string;
+            stickyColumns?: {
+                left?: number;
+                right?: number;
+            };
+        }> & Readonly<{}>, {
+            wrapperRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+            scrollEl: import("vue").ComputedRef<HTMLElement | undefined>;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+            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").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
+    } & 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;
+        };
+    }> & Omit<Readonly<{
+        columns?: BxTableColumn[];
+        bordered?: boolean;
+        radius?: "none" | "sm" | "md" | "lg";
+        variant?: "plain" | "card";
+        hoverable?: boolean;
+        dense?: boolean;
+        stickyHeader?: boolean;
+        fill?: boolean;
+        maxHeight?: string;
+        stickyColumns?: {
+            left?: number;
+            right?: number;
+        };
+    }> & Readonly<{}>, "wrapperRef" | ("fill" | "bordered" | "hoverable" | "radius" | "maxHeight" | "variant" | "columns" | "dense" | "stickyHeader" | "stickyColumns") | "scrollEl"> & {
+        wrapperRef: HTMLDivElement | undefined;
+        scrollEl: HTMLElement | undefined;
+    } & {} & import("vue").ComponentCustomProperties & {} & {
+        $slots: {
+            default?: () => import("vue").VNode[] | import("vue").VNode;
+            'header-cell'?: (scope: {
+                column: BxTableColumn;
+                index: number;
+            }) => import("vue").VNode[] | import("vue").VNode;
+        };
+    }) | undefined>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    import: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onImport?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

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

@@ -0,0 +1,68 @@
+import type { BatchFileFormat, BatchNaming, BatchFailedRow } from '../../util/batch/export';
+import type { BatchCsvFormat } from '../../util/batch/csv';
+export type BatchExportKind = 'files' | 'csv';
+export interface BatchExportRunOptions {
+    kind: BatchExportKind;
+    format: BatchFileFormat | BatchCsvFormat;
+    naming: BatchNaming;
+    delimiter: ',' | ';';
+    prewarm: boolean;
+    signal: AbortSignal;
+    onProgress: (progress: {
+        done: number;
+        total: number;
+        failed?: number;
+        current?: number;
+    }) => void;
+}
+export interface BatchExportRunResult {
+    /** What to hand out: the zip / single file, or the CSV. */
+    output?: {
+        blob: Blob;
+        fileName: string;
+    };
+    /** Files count (files export) — for the wording. */
+    fileCount?: number;
+    /** CSV rows whose render URL is over budget (1-based). */
+    overBudget?: number[];
+    /** Pre-warm outcome (CSV). */
+    prewarmed?: {
+        done: number;
+        failed: number;
+    };
+    /** Files export: rows that threw and are missing from `output` (0-based index). */
+    failedRows?: BatchFailedRow[];
+    cancelled?: boolean;
+}
+/**
+ * The batch export dialog: choose format + naming, see what it costs, run,
+ * download. The parent supplies `run` — this component only knows the shape
+ * of the choices and the progress, not how rendering works.
+ */
+type __VLS_Props = {
+    kind: BatchExportKind;
+    rowCount: number;
+    templateName: string;
+    isVideoTemplate: boolean;
+    /** Rows a video batch may contain (tier). */
+    videoBatchMaxSize: number;
+    /** Whether outputs are charged in this context (false = the output is watermarked, which is free). */
+    consumesCredits: boolean;
+    /** Text bindings usable as file names: label → binding key. */
+    namingBindings: {
+        label: string;
+        key: string;
+    }[];
+    run: (opts: BatchExportRunOptions) => Promise<BatchExportRunResult>;
+};
+declare function cancelRun(): void;
+declare const _default: import("vue").DefineComponent<__VLS_Props, {
+    cancelRun: typeof cancelRun;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    cancel: () => any;
+    done: (result: BatchExportRunResult) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onCancel?: (() => any) | undefined;
+    onDone?: ((result: BatchExportRunResult) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

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

@@ -0,0 +1,25 @@
+import { type BatchColumnField } from '../../util/batch/fields';
+/**
+ * Import rows into the batch: parse (delimiter + per-cell type inference from
+ * the studio's parseCSV), match columns to fields, convert per field type.
+ * Columns whose header IS a binding key are matched up front — that is what
+ * "Export as CSV" writes, so a round trip needs no clicking.
+ */
+type __VLS_Props = {
+    columns: BatchColumnField[];
+    currentRowCount: number;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    cancel: () => any;
+    confirm: (payload: {
+        datasets: Record<string, unknown>[];
+        mode: "append" | "replace";
+    }) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onCancel?: (() => any) | undefined;
+    onConfirm?: ((payload: {
+        datasets: Record<string, unknown>[];
+        mode: "append" | "replace";
+    }) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

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

@@ -11,6 +11,12 @@ type __VLS_Props = {
     serialWidth?: number;
     serialHeight?: number;
     preview?: string;
+    /**
+     * An individually pre-populated render of this template (`image.bluepic.io
+     * ?role=preview`), layered over `preview` in the skeleton until the live
+     * sandbox itself is ready. Omit when nothing pre-populates this view.
+     */
+    personalizedPreviewSrc?: string | null;
     data?: {
         [k: string]: unknown;
     };
@@ -29,6 +35,7 @@ declare function render(options: {
     watermark: boolean;
     resultType: 'blob';
     externalCanvas: HTMLCanvasElement | null;
+    svgLoadWaitDelay?: number;
 }): Promise<Blob>;
 declare function render(options: {
     type: 'image/png' | 'image/jpeg' | 'image/jpge' | 'image/webp';
@@ -43,6 +50,7 @@ declare function render(options: {
     watermark: boolean;
     resultType: 'canvas';
     externalCanvas: HTMLCanvasElement | null;
+    svgLoadWaitDelay?: number;
 }): Promise<HTMLCanvasElement>;
 declare const _default: import("vue").DefineComponent<__VLS_Props, {
     render: typeof render;