@svgrid/enterprise 2.5.3 → 2.6.0

package/dist/SvAlertRuleEditor.svelte.d.ts

@@ -0,0 +1,13 @@
+import type { ExprColumn } from './expressions/expression-columns';
+import type { AlertRule } from './alerts/alert-types';
+type Props = {
+    open?: boolean;
+    columns: ReadonlyArray<ExprColumn>;
+    rule?: AlertRule | null;
+    rows?: ReadonlyArray<Record<string, unknown>>;
+    onSave?: (rule: AlertRule) => void;
+    onClose?: () => void;
+};
+declare const SvAlertRuleEditor: import("svelte").Component<Props, {}, "open">;
+type SvAlertRuleEditor = ReturnType<typeof SvAlertRuleEditor>;
+export default SvAlertRuleEditor;

package/dist/SvAlertsManager.svelte.d.ts

@@ -0,0 +1,14 @@
+import type { ExprColumn } from './expressions/expression-columns';
+import type { AlertRulesManager } from './alerts/alert-storage';
+import type { AlertRule } from './alerts/alert-types';
+type Props = {
+    open?: boolean;
+    manager: AlertRulesManager;
+    columns: ReadonlyArray<ExprColumn>;
+    rows?: ReadonlyArray<Record<string, unknown>>;
+    onChange?: (rules: AlertRule[]) => void;
+    onClose?: () => void;
+};
+declare const SvAlertsManager: import("svelte").Component<Props, {}, "open">;
+type SvAlertsManager = ReturnType<typeof SvAlertsManager>;
+export default SvAlertsManager;

package/dist/SvAlertsPanel.svelte.d.ts

@@ -0,0 +1,9 @@
+import type { AlertEvent } from './alerts/alert-types';
+type Props = {
+    open?: boolean;
+    onJump?: (event: AlertEvent) => void;
+    onClose?: () => void;
+};
+declare const SvAlertsPanel: import("svelte").Component<Props, {}, "open">;
+type SvAlertsPanel = ReturnType<typeof SvAlertsPanel>;
+export default SvAlertsPanel;

package/dist/SvAuthGate.svelte.d.ts

@@ -0,0 +1,22 @@
+/**
+   * SvAuthGate - require a signed-in user before showing its content. Renders a
+   * login / sign-up form when signed out (Supabase Auth via `createSupabaseAuth`)
+   * and its children when signed in, with a small "signed in as ... / Sign out"
+   * bar. Pair with Row-Level Security so each user sees only their own rows.
+   *
+   *   <SvAuthGate {client}>
+   *     <MyStudioScreen />
+   *   </SvAuthGate>
+   */
+import type { Snippet } from 'svelte';
+import { type SupabaseAuthClientLike } from './sources/auth-supabase';
+type Props = {
+    client: SupabaseAuthClientLike;
+    children: Snippet;
+    title?: string;
+    /** Show the "signed in as ... / Sign out" bar. Default true. */
+    showBar?: boolean;
+};
+declare const SvAuthGate: import("svelte").Component<Props, {}, "">;
+type SvAuthGate = ReturnType<typeof SvAuthGate>;
+export default SvAuthGate;

package/dist/SvBoard.svelte.d.ts

@@ -0,0 +1,35 @@
+/**
+   * SvBoard - a Kanban board over an entity's rows. Columns are the options of an
+   * `enum` field (`groupBy`); each row is a card grouped into its column. Drag a
+   * card to another column to change its `groupBy` value (fires `onMove`). A real
+   * pipeline / task / ticket board, not a report - the signature view that makes a
+   * Studio app read like a product.
+   *
+   * Pure presentation over plain rows + an EntitySchema (same inputs as
+   * SvSchemaChart / SvGridEditPanel), so both the generated app and the designer
+   * preview render it identically.
+   */
+import type { EntitySchema } from './schema';
+type Row = Record<string, unknown>;
+type $$ComponentProps = {
+    schema: EntitySchema<any>;
+    rows?: ReadonlyArray<Row>;
+    /** Show shimmer placeholders (first load) instead of columns. */
+    loading?: boolean;
+    /** The enum field whose options become the columns. */
+    groupBy: string;
+    /** Field shown as the card title. */
+    titleField: string;
+    /** Optional numeric/text field shown as a chip on the card. */
+    badgeField?: string;
+    /** Optional secondary line on the card. */
+    subtitleField?: string;
+    /** Called with (rowId, newColumnValue) when a card is dropped in a column. */
+    onMove?: (id: string, value: string) => void;
+    /** Called with the card's row id when it is clicked (drill to a detail page). */
+    onOpen?: (id: string) => void;
+    height?: number;
+};
+declare const SvBoard: import("svelte").Component<$$ComponentProps, {}, "">;
+type SvBoard = ReturnType<typeof SvBoard>;
+export default SvBoard;

package/dist/SvExportMenu.svelte.d.ts

@@ -0,0 +1,61 @@
+/**
+   * SvExportMenu - a drop-in export button + menu for a licensed grid. Wraps
+   * `api.exportData` / `api.copyExport` / `api.print` so consumers don't
+   * hand-roll a toolbar in every app:
+   *   - a sectioned format picker with per-format icons + descriptions,
+   *   - a row-scope toggle (current view / selected / all rows),
+   *   - a per-column include picker,
+   *   - copy-to-clipboard + optional print actions,
+   *   - a progress bar + Cancel for large exports (via AbortController),
+   *   - inline error surface when a peer dep is missing or the grid is empty.
+   *
+   * Minimal, unopinionated styling via a few overridable classes / CSS vars.
+   */
+import type { RowData, TableFeatures } from '@svgrid/grid';
+import type { ConditionalFormat } from '@svgrid/grid/format';
+import type { EnterpriseGridApi } from './install';
+import type { ExportFormat, ExportRowSource } from './export';
+declare function $$render<TFeatures extends TableFeatures, TData extends RowData>(): {
+    props: {
+        api: EnterpriseGridApi<TFeatures, TData> | null | undefined;
+        /** Base filename (no extension). Default 'grid'. */
+        filename?: string;
+        /** Which formats to offer, in order. Default xlsx/xls/pdf/csv/tsv/html. */
+        formats?: ReadonlyArray<ExportFormat>;
+        /** Show the "current view / selected / all" scope toggle. Default true. */
+        allowScope?: boolean;
+        /** Show the per-column include checkboxes. Default true. */
+        allowColumns?: boolean;
+        /** Show the "Copy to clipboard" actions. Default true. */
+        allowCopy?: boolean;
+        /** Show a "Print / Save as PDF" action. Default false. */
+        allowPrint?: boolean;
+        /** Initial scope. Default 'displayed'. */
+        scope?: Extract<ExportRowSource<TData>, string>;
+        /** Button label. Default 'Export'. */
+        label?: string;
+        /** Conditional formatting rules to carry into styled exports (pdf/xlsx/html). */
+        conditionalFormats?: ReadonlyArray<ConditionalFormat<TData>>;
+    };
+    exports: {};
+    bindings: "";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<TFeatures extends TableFeatures, TData extends RowData> {
+    props(): ReturnType<typeof $$render<TFeatures, TData>>['props'];
+    events(): ReturnType<typeof $$render<TFeatures, TData>>['events'];
+    slots(): ReturnType<typeof $$render<TFeatures, TData>>['slots'];
+    bindings(): "";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <TFeatures extends TableFeatures, TData extends RowData>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TFeatures, TData>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TFeatures, TData>['props']>, ReturnType<__sveltets_Render<TFeatures, TData>['events']>, ReturnType<__sveltets_Render<TFeatures, TData>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<TFeatures, TData>['bindings']>;
+    } & ReturnType<__sveltets_Render<TFeatures, TData>['exports']>;
+    <TFeatures extends TableFeatures, TData extends RowData>(internal: unknown, props: ReturnType<__sveltets_Render<TFeatures, TData>['props']> & {}): ReturnType<__sveltets_Render<TFeatures, TData>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any, any>['bindings']>;
+}
+declare const SvExportMenu: $$IsomorphicComponent;
+type SvExportMenu<TFeatures extends TableFeatures, TData extends RowData> = InstanceType<typeof SvExportMenu<TFeatures, TData>>;
+export default SvExportMenu;

package/dist/SvExpressionEditor.svelte.d.ts

@@ -0,0 +1,12 @@
+import { type ExprColumn } from './expressions/expression-columns';
+import type { PredicateExpr } from './expressions/expression-types';
+type Props = {
+    columns: ReadonlyArray<ExprColumn>;
+    value?: PredicateExpr;
+    rows?: ReadonlyArray<Record<string, unknown>>;
+    onChange?: (value: PredicateExpr) => void;
+    mode?: 'builder' | 'text';
+};
+declare const SvExpressionEditor: import("svelte").Component<Props, {}, "value" | "mode">;
+type SvExpressionEditor = ReturnType<typeof SvExpressionEditor>;
+export default SvExpressionEditor;

package/dist/SvFileInput.svelte.d.ts

@@ -0,0 +1,20 @@
+/**
+ * SvFileInput - a file / image upload control for the edit form. Picks a file,
+ * shows an image preview (when `image`), and stores a URL. With an `upload`
+ * handler it pushes to your storage and stores the returned URL; without one it
+ * falls back to an inline data URL (great for demos / small assets). Used by
+ * SvGridEditPanel for fields with an `upload` config.
+ */
+type Props = {
+    value: unknown;
+    onChange: (url: string) => void;
+    id?: string;
+    accept?: string;
+    image?: boolean;
+    disabled?: boolean;
+    /** Push the file to storage and resolve with the URL to store. */
+    upload?: (file: File) => Promise<string>;
+};
+declare const SvFileInput: import("svelte").Component<Props, {}, "">;
+type SvFileInput = ReturnType<typeof SvFileInput>;
+export default SvFileInput;

package/dist/SvGridAlerts.svelte.d.ts

@@ -0,0 +1,77 @@
+import type { ConditionalFormat } from '@svgrid/grid/format';
+import type { ExprColumn } from './expressions/expression-columns';
+import type { AlertEvent, AlertRule } from './alerts/alert-types';
+declare function $$render<TRow extends Record<string, unknown>>(): {
+    props: {
+        /** The same rows bound to the grid. In watch mode, observed for changes. */
+        data?: ReadonlyArray<TRow>;
+        /** Columns offered in the rule/expression editors. */
+        columns: ReadonlyArray<ExprColumn>;
+        /** Stable row identity (defaults to `row.id`). */
+        getRowId?: (row: TRow) => string;
+        /** Bindable output: spread into `<SvGrid conditionalFormats={[...]}>`. */
+        formats?: ConditionalFormat<TRow>[];
+        /** Seed rules when storage is empty. */
+        rules?: AlertRule[];
+        /** Persist + share rules under this localStorage key (else in-memory). */
+        storageKey?: string;
+        getValue?: (row: TRow, columnId: string) => unknown;
+        locale?: string | ReadonlyArray<string>;
+        /**
+         * Reactively scan `data` for changes (default). Set `false` when a consumer
+         * drives evaluation through `pushChanged` (large / streaming feeds) - the
+         * overlay then never reads `data` on the hot path.
+         */
+        watch?: boolean;
+        /** Receive the push-mode handle on mount (alternative to `bind:this`). */
+        onReady?: (handle: {
+            /** Feed only the rows that changed (O(changed) evaluation, deferred). */
+            pushChanged: (rows: readonly TRow[]) => void;
+            /** Silently re-arm edges from the full row set (after a data reset). */
+            reseed: (rows: readonly TRow[]) => void;
+            /** Run any pending evaluation immediately. */
+            flush: () => void;
+        }) => void;
+        /**
+         * Rate-limit toasts to at most one per rule per this many ms. Every event is
+         * still logged (the badge stays accurate); this only stops a busy live feed
+         * from turning into a toast storm. `0` (default) = no throttle.
+         */
+        toastCooldownMs?: number;
+        /** Show the built-in badge + manage buttons. */
+        controls?: boolean;
+        panelOpen?: boolean;
+        managerOpen?: boolean;
+        /** Called when the user clicks "Go to row" in the panel. */
+        onJump?: (event: AlertEvent) => void;
+    };
+    exports: {
+        pushChanged: (rows: ReadonlyArray<TRow>) => void;
+        reseed: (rows: ReadonlyArray<TRow>) => void;
+        flush: () => void;
+    };
+    bindings: "formats" | "panelOpen" | "managerOpen";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<TRow extends Record<string, unknown>> {
+    props(): ReturnType<typeof $$render<TRow>>['props'];
+    events(): ReturnType<typeof $$render<TRow>>['events'];
+    slots(): ReturnType<typeof $$render<TRow>>['slots'];
+    bindings(): "formats" | "panelOpen" | "managerOpen";
+    exports(): {
+        pushChanged: (rows: readonly TRow[]) => void;
+        reseed: (rows: readonly TRow[]) => void;
+        flush: () => void;
+    };
+}
+interface $$IsomorphicComponent {
+    new <TRow extends Record<string, unknown>>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TRow>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TRow>['props']>, ReturnType<__sveltets_Render<TRow>['events']>, ReturnType<__sveltets_Render<TRow>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<TRow>['bindings']>;
+    } & ReturnType<__sveltets_Render<TRow>['exports']>;
+    <TRow extends Record<string, unknown>>(internal: unknown, props: ReturnType<__sveltets_Render<TRow>['props']> & {}): ReturnType<__sveltets_Render<TRow>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const SvGridAlerts: $$IsomorphicComponent;
+type SvGridAlerts<TRow extends Record<string, unknown>> = InstanceType<typeof SvGridAlerts<TRow>>;
+export default SvGridAlerts;

package/dist/SvGridBoard.svelte.d.ts

@@ -0,0 +1,30 @@
+import type { ColumnDef, RowData, TableFeatures, BoardConfig } from "@svgrid/grid";
+declare function $$render<TFeatures extends TableFeatures = TableFeatures, TData extends RowData = RowData>(): {
+    props: {
+        data: ReadonlyArray<TData>;
+        columns: Array<ColumnDef<TFeatures, TData>>;
+        board: BoardConfig<TFeatures, TData>;
+        getRowId?: (row: TData, index: number) => string;
+    };
+    exports: {};
+    bindings: "";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<TFeatures extends TableFeatures = TableFeatures, TData extends RowData = RowData> {
+    props(): ReturnType<typeof $$render<TFeatures, TData>>['props'];
+    events(): ReturnType<typeof $$render<TFeatures, TData>>['events'];
+    slots(): ReturnType<typeof $$render<TFeatures, TData>>['slots'];
+    bindings(): "";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <TFeatures extends TableFeatures = TableFeatures, TData extends RowData = RowData>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TFeatures, TData>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TFeatures, TData>['props']>, ReturnType<__sveltets_Render<TFeatures, TData>['events']>, ReturnType<__sveltets_Render<TFeatures, TData>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<TFeatures, TData>['bindings']>;
+    } & ReturnType<__sveltets_Render<TFeatures, TData>['exports']>;
+    <TFeatures extends TableFeatures = TableFeatures, TData extends RowData = RowData>(internal: unknown, props: ReturnType<__sveltets_Render<TFeatures, TData>['props']> & {}): ReturnType<__sveltets_Render<TFeatures, TData>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any, any>['bindings']>;
+}
+declare const SvGridBoard: $$IsomorphicComponent;
+type SvGridBoard<TFeatures extends TableFeatures = TableFeatures, TData extends RowData = RowData> = InstanceType<typeof SvGridBoard<TFeatures, TData>>;
+export default SvGridBoard;

package/dist/SvGridEditPanel.svelte.d.ts

@@ -0,0 +1,73 @@
+type EditRow = Record<string, unknown>;
+import { type CellEditorOption } from '@svgrid/grid';
+import { type EntitySchema, type FormSection } from './schema';
+import { type EditMode } from './edit-panel';
+import type { RelationLookup } from './sources/relation-lookup';
+declare function $$render<TData extends EditRow>(): {
+    props: {
+        schema: EntitySchema<TData>;
+        row?: TData | null;
+        open?: boolean;
+        title?: string;
+        submitLabel?: string;
+        /** 'drawer' (right slide-over, default), 'modal' (centered popup), or 'inline'. */
+        presentation?: "inline" | "modal" | "drawer";
+        /**
+         * Lookup providers keyed by field name. A `relation` field with a lookup
+         * renders a searchable picker (search the related entity, store the key).
+         * Build them with `createRelationLookup`.
+         */
+        lookups?: Record<string, RelationLookup>;
+        /** File/image upload handlers by field name (return the URL to store). */
+        uploads?: Record<string, (file: File) => Promise<string>>;
+        /**
+         * Dependent (cascading) options by field name - compute a field's choices
+         * from the current form values, e.g. City from Country. The field's value is
+         * cleared when it stops being a valid option.
+         */
+        dependentOptions?: Record<string, (values: Partial<TData>) => ReadonlyArray<CellEditorOption>>;
+        /**
+         * Remember the floating modal's window layout (pin / size / maximized) in
+         * localStorage under this key, so it reopens where the user left it.
+         */
+        persistKey?: string;
+        /** Form column count. Defaults to the schema's `form.columns`, else 2. A field
+         *  with `span: 2` spans all columns. */
+        columns?: 1 | 2 | 3;
+        /** Restrict + order the form fields (by field name). Default: all schema fields. */
+        formFields?: string[];
+        /** Group fields into titled fieldsets, overriding the schema's `form.sections`.
+         *  Fields not in any section render in a trailing default group. When set,
+         *  `formFields` ordering is per-section. */
+        sections?: FormSection[];
+        /** Dialog width for the modal / drawer presentations. Default 'md'. */
+        formSize?: "sm" | "md" | "lg";
+        onSubmit: (payload: {
+            mode: EditMode;
+            id: string | null;
+            values: Partial<TData>;
+        }) => void | Promise<void>;
+        onCancel?: () => void;
+    };
+    exports: {};
+    bindings: "";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<TData extends EditRow> {
+    props(): ReturnType<typeof $$render<TData>>['props'];
+    events(): ReturnType<typeof $$render<TData>>['events'];
+    slots(): ReturnType<typeof $$render<TData>>['slots'];
+    bindings(): "";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <TData extends EditRow>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TData>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TData>['props']>, ReturnType<__sveltets_Render<TData>['events']>, ReturnType<__sveltets_Render<TData>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<TData>['bindings']>;
+    } & ReturnType<__sveltets_Render<TData>['exports']>;
+    <TData extends EditRow>(internal: unknown, props: ReturnType<__sveltets_Render<TData>['props']> & {}): ReturnType<__sveltets_Render<TData>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const SvGridEditPanel: $$IsomorphicComponent;
+type SvGridEditPanel<TData extends EditRow> = InstanceType<typeof SvGridEditPanel<TData>>;
+export default SvGridEditPanel;

package/dist/SvGridMasterDetail.svelte.d.ts

@@ -0,0 +1,49 @@
+type MdRow = Record<string, unknown>;
+import { type EntitySchema } from './schema';
+declare function $$render<TParent extends MdRow, TChild extends MdRow>(): {
+    props: {
+        /** The master entity. */
+        schema: EntitySchema<TParent>;
+        /** Master rows. */
+        data: ReadonlyArray<TParent>;
+        /** The detail entity, rendered in the nested grid. */
+        detailSchema: EntitySchema<TChild>;
+        /** Return the child rows for a given master row. */
+        getChildren: (parent: TParent) => ReadonlyArray<TChild>;
+        /** Height of the outer grid. Default 320. */
+        containerHeight?: number | string;
+        /** Height of each nested detail grid. Default 200. */
+        detailHeight?: number | string;
+        /** When set, a parent row click calls this (with the row id) to drill into a
+         *  detail page, instead of expanding the inline child grid. */
+        onParentClick?: (id: string) => void;
+        /** Stretch columns to fill the width, like a standard grid. Default `true` so the
+         *  master + detail cells match a plain `<SvGrid>` instead of using natural widths. */
+        fitColumns?: boolean;
+        /** Row height (px) - keep in sync with your other grids. Defaults to the grid's own 30. */
+        rowHeight?: number;
+        /** Zebra-stripe the rows (match a striped grid). */
+        zebraRows?: boolean;
+    };
+    exports: {};
+    bindings: "";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<TParent extends MdRow, TChild extends MdRow> {
+    props(): ReturnType<typeof $$render<TParent, TChild>>['props'];
+    events(): ReturnType<typeof $$render<TParent, TChild>>['events'];
+    slots(): ReturnType<typeof $$render<TParent, TChild>>['slots'];
+    bindings(): "";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <TParent extends MdRow, TChild extends MdRow>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TParent, TChild>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TParent, TChild>['props']>, ReturnType<__sveltets_Render<TParent, TChild>['events']>, ReturnType<__sveltets_Render<TParent, TChild>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<TParent, TChild>['bindings']>;
+    } & ReturnType<__sveltets_Render<TParent, TChild>['exports']>;
+    <TParent extends MdRow, TChild extends MdRow>(internal: unknown, props: ReturnType<__sveltets_Render<TParent, TChild>['props']> & {}): ReturnType<__sveltets_Render<TParent, TChild>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any, any>['bindings']>;
+}
+declare const SvGridMasterDetail: $$IsomorphicComponent;
+type SvGridMasterDetail<TParent extends MdRow, TChild extends MdRow> = InstanceType<typeof SvGridMasterDetail<TParent, TChild>>;
+export default SvGridMasterDetail;

package/dist/SvGridScheduler.svelte.d.ts

@@ -0,0 +1,30 @@
+import type { ColumnDef, RowData, TableFeatures, SchedulerConfig } from "@svgrid/grid";
+declare function $$render<TFeatures extends TableFeatures = TableFeatures, TData extends RowData = RowData>(): {
+    props: {
+        data: ReadonlyArray<TData>;
+        columns: Array<ColumnDef<TFeatures, TData>>;
+        scheduler: SchedulerConfig<TFeatures, TData>;
+        getRowId?: (row: TData, index: number) => string;
+    };
+    exports: {};
+    bindings: "";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<TFeatures extends TableFeatures = TableFeatures, TData extends RowData = RowData> {
+    props(): ReturnType<typeof $$render<TFeatures, TData>>['props'];
+    events(): ReturnType<typeof $$render<TFeatures, TData>>['events'];
+    slots(): ReturnType<typeof $$render<TFeatures, TData>>['slots'];
+    bindings(): "";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <TFeatures extends TableFeatures = TableFeatures, TData extends RowData = RowData>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TFeatures, TData>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TFeatures, TData>['props']>, ReturnType<__sveltets_Render<TFeatures, TData>['events']>, ReturnType<__sveltets_Render<TFeatures, TData>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<TFeatures, TData>['bindings']>;
+    } & ReturnType<__sveltets_Render<TFeatures, TData>['exports']>;
+    <TFeatures extends TableFeatures = TableFeatures, TData extends RowData = RowData>(internal: unknown, props: ReturnType<__sveltets_Render<TFeatures, TData>['props']> & {}): ReturnType<__sveltets_Render<TFeatures, TData>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any, any>['bindings']>;
+}
+declare const SvGridScheduler: $$IsomorphicComponent;
+type SvGridScheduler<TFeatures extends TableFeatures = TableFeatures, TData extends RowData = RowData> = InstanceType<typeof SvGridScheduler<TFeatures, TData>>;
+export default SvGridScheduler;

package/dist/SvImportDialog.svelte.d.ts

@@ -0,0 +1,88 @@
+/**
+   * SvImportDialog - a drop-in, production-hardened "bring your data in"
+   * dialog for a licensed grid. The mirror image of SvExportMenu: where that
+   * sends the grid OUT, this pulls a file IN and lines it up with the grid's
+   * own columns.
+   *
+   *   - drag-drop / browse / paste (Excel .xlsx, CSV, TSV, JSON),
+   *   - grid-aware auto-mapping: source headers matched to your columns,
+   *   - per-column mapping UI (retarget or skip any source column),
+   *   - typed coercion driven by each column's `format` (currency/date/...),
+   *   - a live, NON-BLOCKING preview with per-cell validation errors,
+   *   - size / row guard-rails, cancel, and a full focus trap.
+   *
+   * The parse happens ONCE (readImportMatrix); re-mapping runs on a chunked,
+   * cancelable worker loop (mapImportMatrixAsync) so even a 100k-row file
+   * never freezes the tab. Styling uses the same overridable CSS vars as the
+   * rest of the suite.
+   */
+import type { RowData, TableFeatures } from '@svgrid/grid';
+import type { EnterpriseGridApi } from './install';
+import { type ImportResult, type ImportValidator } from './import';
+declare function $$render<TFeatures extends TableFeatures, TData extends RowData>(): {
+    props: {
+        api: EnterpriseGridApi<TFeatures, TData> | null | undefined;
+        /** Trigger-button label. Default 'Import'. */
+        label?: string;
+        /** Dialog heading. Default 'Import data'. */
+        title?: string;
+        /** Where committed rows land (append mode). Default 'bottom'. */
+        commitAt?: "top" | "bottom" | number;
+        /** Create a grid column for any imported field the grid doesn't already
+         *  have, so "Import as new field" actually shows up. Default true. */
+        createColumns?: boolean;
+        /** Offer an Append / Replace-all mode toggle. Replace clears the grid's
+         *  existing rows first (and still creates any missing columns). Default true. */
+        allowReplace?: boolean;
+        /** Initial commit mode. Default 'append'. */
+        defaultMode?: "append" | "replace";
+        /** In Replace mode, offer a "Replace columns" checkbox that also REMOVES
+         *  grid columns absent from the file, so the grid matches it exactly.
+         *  Default true (the checkbox itself defaults to off). */
+        allowColumnPrune?: boolean;
+        /** Accept filter for the file picker. */
+        accept?: string;
+        /** Rows to show in the preview table. Default 8. */
+        previewRows?: number;
+        /** Block the import while any cell failed to coerce. Default false. */
+        strict?: boolean;
+        /** Optional per-row validator, surfaced in the preview like type errors. */
+        validator?: ImportValidator<TData>;
+        /** Reject a file larger than this many bytes. Default 25 MB. */
+        maxBytes?: number;
+        /** Cap on data rows. See `overLimit` for what happens past it. */
+        maxRows?: number;
+        /** Over `maxRows`: 'reject' (default) refuses the file; 'truncate' keeps
+         *  the first `maxRows` and warns. */
+        overLimit?: "reject" | "truncate";
+        /** Cap the errors collected (memory guard). Default 500. */
+        maxErrors?: number;
+        /** Drop duplicate rows by this target field (keeps the last). */
+        dedupeBy?: keyof TData | (string & {});
+        /** Text encoding for CSV/TSV/JSON files. Default 'utf-8'. */
+        encoding?: string;
+        /** Called after rows are committed into the grid. */
+        onImported?: (result: ImportResult<TData>) => void;
+    };
+    exports: {};
+    bindings: "";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<TFeatures extends TableFeatures, TData extends RowData> {
+    props(): ReturnType<typeof $$render<TFeatures, TData>>['props'];
+    events(): ReturnType<typeof $$render<TFeatures, TData>>['events'];
+    slots(): ReturnType<typeof $$render<TFeatures, TData>>['slots'];
+    bindings(): "";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <TFeatures extends TableFeatures, TData extends RowData>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TFeatures, TData>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TFeatures, TData>['props']>, ReturnType<__sveltets_Render<TFeatures, TData>['events']>, ReturnType<__sveltets_Render<TFeatures, TData>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<TFeatures, TData>['bindings']>;
+    } & ReturnType<__sveltets_Render<TFeatures, TData>['exports']>;
+    <TFeatures extends TableFeatures, TData extends RowData>(internal: unknown, props: ReturnType<__sveltets_Render<TFeatures, TData>['props']> & {}): ReturnType<__sveltets_Render<TFeatures, TData>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any, any>['bindings']>;
+}
+declare const SvImportDialog: $$IsomorphicComponent;
+type SvImportDialog<TFeatures extends TableFeatures, TData extends RowData> = InstanceType<typeof SvImportDialog<TFeatures, TData>>;
+export default SvImportDialog;

package/dist/SvLookupInput.svelte.d.ts

@@ -0,0 +1,21 @@
+/**
+   * SvLookupInput - a searchable single-select for a foreign-key ("lookup")
+   * field. It searches the related entity through a `RelationLookup`, shows human
+   * labels, and stores the selected key. Used by SvGridEditPanel for `relation`
+   * fields, and usable on its own.
+   */
+import type { RelationLookup } from './sources/relation-lookup';
+type Props = {
+    value: unknown;
+    lookup: RelationLookup;
+    onSelect: (value: string) => void;
+    id?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    required?: boolean;
+    /** Debounce for the search query, ms. Default 200. */
+    debounceMs?: number;
+};
+declare const SvLookupInput: import("svelte").Component<Props, {}, "">;
+type SvLookupInput = ReturnType<typeof SvLookupInput>;
+export default SvLookupInput;