shutro-erp 0.2.0 → 0.3.0

package/dist/import/service.d.ts

@@ -0,0 +1,153 @@
+/**
+ * What the import routes and the background worker share (RFC 0014): reading sessions as their user, the fields of
+ * a model, options, saved mappings and module templates, running an import and recording its outcome.
+ */
+import { type ApiModel, type KoshRegistry } from '../server/index.js';
+import type { Driver, Env, Shutro } from '../server/orm.js';
+import type { Cell } from './convert.js';
+import { type ColumnMapping } from './mapping.js';
+import { type ImportField, type ImportModels, type ImportOptions, type ImportResult, type RowError, type UndoData } from './run.js';
+type Row = Record<string, unknown>;
+export interface Rows {
+    readonly ids: readonly number[];
+    readonly length: number;
+    load(keys: readonly string[]): Promise<{
+        read(keys: readonly string[]): Row[];
+    }>;
+    write(values: unknown): Promise<void>;
+    unlink(): Promise<void>;
+}
+interface Ref {
+    search(q: unknown): Promise<Rows>;
+    create(rows: readonly unknown[]): Promise<Rows>;
+}
+export declare const ref: (env: Env, name: string) => Ref;
+/** Rows a file may have (`KOSH_IMPORT_MAX_ROWS`). */
+export declare const IMPORT_ROWS = 1000000;
+/** Rows run within the request; larger files run as a background job (RFC 0014 §5.3). */
+export declare const INLINE_ROWS = 2000;
+/** The default file size limit (`KOSH_IMPORT_MAX_BYTES`). */
+export declare const IMPORT_MAX_BYTES = 50000000;
+/** How long an import can be undone (RFC 0014 §5.5). */
+export declare const UNDO_DAYS = 7;
+/** The background job that runs an import or its dry run: `{ session, dryRun }`. */
+export declare const RUN_JOB = "import.run";
+/** The event a background run emits when it ends (a notification for its user). */
+export declare const FINISHED_TOPIC = "import.finished";
+/** The options of a mapping request (or a template), checked. */
+export declare function parseOptions(input: unknown): ImportOptions;
+/** A result as the API shows it: undo data stays on the server. */
+export declare const shown: ({ undo: _, ...result }: ImportResult) => Omit<ImportResult, 'undo'>;
+export declare const isXlsx: (bytes: Uint8Array) => boolean;
+/** The cells of a file. @throws {HttpProblem} 422 when it cannot be read */
+export declare function readTable(bytes: Uint8Array, type: 'csv' | 'xlsx', sheet: string | null): Cell[][];
+export declare const dataRows: (table: readonly (readonly Cell[])[], options: ImportOptions) => number;
+export interface Session {
+    readonly id: number;
+    readonly rows: Rows;
+    readonly model: ApiModel;
+    readonly fileName: string;
+    readonly fileType: 'csv' | 'xlsx';
+    readonly file: Uint8Array;
+    readonly sheet: string | null;
+    readonly columns: readonly ColumnMapping[];
+    readonly options: ImportOptions;
+    readonly state: string;
+    readonly rowCount: number;
+    readonly undo: UndoData | null;
+    /** The errors and the file rows of the records left out. */
+    readonly rejected: {
+        readonly errors: readonly RowError[];
+        readonly rows: readonly number[];
+    };
+    readonly importedAt: Date | null;
+    readonly result: unknown;
+    readonly resultDry: boolean;
+    readonly failure: string | null;
+}
+/** A saved mapping or a module's template, as the screen lists them. */
+export interface SavedMapping {
+    /** A record id, or `module.key` for a template. */
+    readonly id: string;
+    readonly name: string;
+    readonly model: string;
+    readonly template: boolean;
+    readonly shared: boolean;
+    readonly own: boolean;
+    readonly columns: readonly {
+        readonly header: string;
+        readonly field: string;
+    }[];
+    readonly options: ImportOptions;
+}
+export interface ImportContext {
+    readonly shutro: Shutro;
+    readonly driver: Driver;
+    readonly registry: KoshRegistry;
+}
+/** A session as the API shows it. */
+export interface SessionView {
+    readonly id: number;
+    readonly model: string;
+    readonly fileName: string;
+    readonly fileType: 'csv' | 'xlsx';
+    readonly sheet: string | null;
+    readonly sheets: readonly string[];
+    readonly state: string;
+    readonly rowCount: number;
+    /** Runs as a background job. */
+    readonly background: boolean;
+    readonly headers: readonly string[];
+    readonly sample: readonly (readonly unknown[])[];
+    readonly columns: readonly ColumnMapping[];
+    readonly options: ImportOptions;
+    readonly fields: readonly {
+        readonly key: string;
+        readonly kind: string;
+        readonly label: string;
+        readonly required: boolean;
+        readonly keyable: boolean;
+        readonly line?: string;
+        readonly target?: string;
+    }[];
+    readonly progress: {
+        readonly done: number;
+        readonly total: number;
+    } | null;
+    readonly result: unknown;
+    readonly resultDry: boolean;
+    readonly failure: string | null;
+    readonly importedAt: string | null;
+    readonly undoUntil: string | null;
+    /** Rows left out by the last import (the rejected-rows file). */
+    readonly rejected: number;
+}
+/** What the routes and the worker share. */
+export interface ImportService {
+    readonly inlineRows: number;
+    readonly catalog: ImportModels;
+    /** @throws {HttpProblem} 403 without the Import data access level */
+    guard(env: Env): void;
+    /** @throws {HttpProblem} 404 for an unknown model, 403 without its permissions */
+    modelFor(env: Env, name: string): ApiModel;
+    fieldsOf(env: Env, model: ApiModel): Map<string, ImportField>;
+    columnFields(fields: ReadonlyMap<string, ImportField>): ImportField[];
+    /** @throws {HttpProblem} 404 when the session is not the user's */
+    sessionOf(env: Env, id: number): Promise<Session>;
+    progressOf(env: Env, session: number): Promise<{
+        done: number;
+        total: number;
+    } | null>;
+    startProgress(env: Env, session: number, total: number): Promise<void>;
+    reportProgress(company: number, session: number, done: number, total: number): Promise<void>;
+    describe(env: Env, session: Session, table: readonly (readonly Cell[])[]): Promise<SessionView>;
+    mappingsFor(env: Env, model: string): Promise<SavedMapping[]>;
+    fitting(mappings: readonly SavedMapping[], headers: readonly string[]): SavedMapping | null;
+    applyMapping(mapping: SavedMapping, headers: readonly string[], fields: ReadonlyMap<string, ImportField>): ColumnMapping[];
+    execute(env: Env, session: Session, dryRun: boolean, onProgress?: (done: number, total: number) => Promise<void>): Promise<ImportResult>;
+    record(env: Env, session: Session, result: ImportResult, dryRun: boolean, ip?: string): Promise<void>;
+}
+export declare function createImportService(context: ImportContext, limits?: {
+    readonly inlineRows?: number;
+}): ImportService;
+export {};

package/dist/import/service.js

@@ -0,0 +1,367 @@
+/**
+ * What the import routes and the background worker share (RFC 0014): reading sessions as their user, the fields of
+ * a model, options, saved mappings and module templates, running an import and recording its outcome.
+ */
+import { announceChange, audit, HttpProblem, publicApiModels, } from '../server/index.js';
+import { readCsv } from './csv.js';
+import { normalize } from './mapping.js';
+import { importFields, runImport, } from './run.js';
+import { readXlsx, XlsxError, xlsxSheetNames } from './xlsx.js';
+export const ref = (env, name) => env.model(name);
+/** Rows a file may have (`KOSH_IMPORT_MAX_ROWS`). */
+export const IMPORT_ROWS = 1_000_000;
+/** Rows run within the request; larger files run as a background job (RFC 0014 §5.3). */
+export const INLINE_ROWS = 2_000;
+/** The default file size limit (`KOSH_IMPORT_MAX_BYTES`). */
+export const IMPORT_MAX_BYTES = 50_000_000;
+/** How long an import can be undone (RFC 0014 §5.5). */
+export const UNDO_DAYS = 7;
+/** The background job that runs an import or its dry run: `{ session, dryRun }`. */
+export const RUN_JOB = 'import.run';
+/** The event a background run emits when it ends (a notification for its user). */
+export const FINISHED_TOPIC = 'import.finished';
+/** Rows of the file shown with the mapping. */
+const SAMPLE_ROWS = 5;
+const DATE_ORDERS = ['dmy', 'mdy', 'ymd'];
+const MODES = ['create', 'update', 'upsert'];
+const invalid = (detail) => new HttpProblem(400, 'invalid-options', 'Invalid options', detail);
+/** The options of a mapping request (or a template), checked. */
+export function parseOptions(input) {
+    if (input === undefined || input === null)
+        return {};
+    if (typeof input !== 'object' || Array.isArray(input))
+        throw invalid('options is an object.');
+    const o = input;
+    const out = {};
+    if (o['dateOrder'] !== undefined) {
+        if (!DATE_ORDERS.includes(String(o['dateOrder'])))
+            throw invalid('dateOrder is dmy, mdy or ymd.');
+        out.dateOrder = o['dateOrder'];
+    }
+    if (o['decimal'] !== undefined) {
+        if (o['decimal'] !== '.' && o['decimal'] !== ',')
+            throw invalid('decimal is "." or ",".');
+        out.decimal = o['decimal'];
+    }
+    if (o['timeZone'] !== undefined) {
+        const zone = String(o['timeZone']);
+        try {
+            new Intl.DateTimeFormat('en', { timeZone: zone });
+        }
+        catch {
+            throw invalid(`No time zone '${zone}'.`);
+        }
+        out.timeZone = zone;
+    }
+    if (o['headerRow'] !== undefined)
+        out.headerRow = o['headerRow'] === true;
+    if (o['mode'] !== undefined) {
+        if (!MODES.includes(String(o['mode'])))
+            throw invalid('mode is create, update or upsert.');
+        out.mode = o['mode'];
+    }
+    if (o['onError'] !== undefined) {
+        if (o['onError'] !== 'stop' && o['onError'] !== 'skip')
+            throw invalid('onError is stop or skip.');
+        out.onError = o['onError'];
+    }
+    if (o['key'] !== undefined && o['key'] !== null)
+        out.key = String(o['key']);
+    return out;
+}
+/** A result as the API shows it: undo data stays on the server. */
+export const shown = ({ undo: _, ...result }) => result;
+export const isXlsx = (bytes) => bytes[0] === 0x50 && bytes[1] === 0x4b && bytes[2] === 0x03 && bytes[3] === 0x04;
+/** The cells of a file. @throws {HttpProblem} 422 when it cannot be read */
+export function readTable(bytes, type, sheet) {
+    try {
+        return type === 'xlsx' ? readXlsx(bytes, sheet ?? undefined).rows : readCsv(bytes).rows;
+    }
+    catch (error) {
+        if (!(error instanceof XlsxError))
+            throw error;
+        throw new HttpProblem(422, 'unreadable-file', 'The file cannot be read', error.message);
+    }
+}
+export const dataRows = (table, options) => Math.max(0, table.length - (options.headerRow === false ? 0 : 1));
+const SESSION_FIELDS = [
+    'resModel',
+    'fileName',
+    'fileType',
+    'file',
+    'sheet',
+    'columns',
+    'options',
+    'state',
+    'rowCount',
+    'undo',
+    'rejected',
+    'importedAt',
+    'result',
+    'resultDry',
+    'failure',
+];
+export function createImportService(context, limits = {}) {
+    const inlineRows = limits.inlineRows ?? INLINE_ROWS;
+    const { driver, shutro } = context;
+    const registry = context.registry.registry;
+    const models = publicApiModels(context.registry);
+    /** How records of `name` are found from text: its name field and its own unique char fields. */
+    const targets = (name) => {
+        if (!registry.models.has(name))
+            return null;
+        const description = registry.describe(name);
+        const keys = new Set();
+        const unique = [
+            ...description.sqlConstraints.filter((c) => c.kind === 'unique').map((c) => c.fields),
+            ...description.indexes.filter((i) => i.unique && !i.partial).map((i) => i.fields),
+        ];
+        for (const fields of unique) {
+            const own = fields.filter((f) => f !== 'company');
+            const [only] = own;
+            if (own.length === 1 && only !== undefined && description.fields[only]?.kind === 'char')
+                keys.add(only);
+        }
+        return { model: name, recName: description.recName, keys: [...keys] };
+    };
+    const catalog = {
+        models,
+        targets,
+        inverseOf: (model, field) => {
+            const raw = registry.get(model).model.fields;
+            const inverse = raw[field]?.inverseField;
+            return typeof inverse === 'string' ? inverse : null;
+        },
+    };
+    const guard = (env) => {
+        if (!env.administrator && !env.groups.has('import.user'))
+            throw new HttpProblem(403, 'access', 'Import users only', 'Importing data needs the Import data access level.');
+    };
+    /** The model a user may import into. */
+    const modelFor = (env, name) => {
+        const model = models.get(name);
+        if (model === undefined)
+            throw new HttpProblem(404, 'unknown-model', 'Unknown model', `No model is named '${name}'.`);
+        env.access.check(name, 'import');
+        // Creating or updating: one of them, checked again for the mode of the run.
+        if (!env.access.can(name, 'create'))
+            env.access.check(name, 'write');
+        return model;
+    };
+    const fieldsOf = (env, model) => importFields(env, model, catalog);
+    /** The fields a column may fill (not the one2many fields themselves: their lines' fields). */
+    const columnFields = (fields) => [...fields.values()].filter((f) => f.kind !== 'one2many');
+    /** The caller's session `id` (a record rule hides the others: 404). */
+    const sessionOf = async (env, id) => {
+        guard(env);
+        const rows = await ref(env, 'import.session').search({ where: { id }, limit: 1 });
+        const [row] = (await rows.load(SESSION_FIELDS)).read(SESSION_FIELDS);
+        if (rows.length === 0 || row === undefined)
+            throw new HttpProblem(404, 'not-found', 'No such import', `No import #${id} of yours.`);
+        return {
+            id,
+            rows,
+            model: modelFor(env, String(row['resModel'])),
+            fileName: String(row['fileName']),
+            fileType: row['fileType'] === 'xlsx' ? 'xlsx' : 'csv',
+            file: row['file'],
+            sheet: typeof row['sheet'] === 'string' ? row['sheet'] : null,
+            columns: row['columns'] ?? [],
+            options: row['options'] ?? {},
+            state: String(row['state']),
+            rowCount: Number(row['rowCount']),
+            undo: row['undo'] ?? null,
+            rejected: row['rejected'] ?? { errors: [], rows: [] },
+            importedAt: typeof row['importedAt'] === 'string' ? new Date(row['importedAt']) : null,
+            result: row['result'] ?? null,
+            resultDry: row['resultDry'] === true,
+            failure: typeof row['failure'] === 'string' ? row['failure'] : null,
+        };
+    };
+    /** How far a background run is (the progress row is the system's). */
+    const progressOf = (env, session) => env.asSuperuser({ reason: 'import progress' }, async (su) => {
+        const found = await ref(su, 'import.progress').search({ where: { session }, limit: 1 });
+        const [row] = (await found.load(['done', 'total'])).read(['done', 'total']);
+        return row === undefined ? null : { done: Number(row['done']), total: Number(row['total']) };
+    });
+    const writeProgress = async (su, session, done, total) => {
+        const found = await ref(su, 'import.progress').search({ where: { session }, limit: 1 });
+        if (found.length === 0)
+            await ref(su, 'import.progress').create([{ session, done, total }]);
+        else
+            await found.write({ done, total });
+    };
+    /** Starts a run's progress in the caller's transaction (it commits with the job it announces). */
+    const startProgress = (env, session, total) => env.asSuperuser({ reason: 'import progress' }, (su) => writeProgress(su, session, 0, total));
+    /** Writes progress in a short transaction of its own, so others see it while the run's goes on. */
+    const reportProgress = (company, session, done, total) => shutro.bootstrap({ reason: 'import progress', company }, (su) => writeProgress(su, session, done, total));
+    /** What the screen shows of a session. */
+    const describe = async (env, session, table) => {
+        const fields = fieldsOf(env, session.model);
+        const header = session.options.headerRow === false ? [] : (table[0] ?? []);
+        return {
+            id: session.id,
+            model: session.model.name,
+            fileName: session.fileName,
+            fileType: session.fileType,
+            sheet: session.sheet,
+            sheets: session.fileType === 'xlsx' ? xlsxSheetNames(session.file) : [],
+            state: session.state,
+            rowCount: session.rowCount,
+            background: session.rowCount > inlineRows,
+            headers: header.map((c) => (c === null ? '' : String(c))),
+            sample: table
+                .slice(session.options.headerRow === false ? 0 : 1, SAMPLE_ROWS + 1)
+                .map((r) => r.map((c) => (c instanceof Date ? c.toISOString() : c))),
+            columns: session.columns,
+            options: session.options,
+            fields: columnFields(fields).map((f) => ({
+                key: f.key,
+                kind: f.kind,
+                label: f.label,
+                required: f.required,
+                keyable: f.keyable,
+                ...(f.line === null ? {} : { line: f.line }),
+                ...(f.target === null ? {} : { target: f.target.model }),
+            })),
+            progress: session.state === 'running' ? await progressOf(env, session.id) : null,
+            result: session.result,
+            resultDry: session.resultDry,
+            failure: session.failure,
+            importedAt: session.importedAt?.toISOString() ?? null,
+            undoUntil: session.state === 'done' && session.importedAt !== null && session.undo !== null
+                ? new Date(session.importedAt.getTime() + UNDO_DAYS * 86_400_000).toISOString()
+                : null,
+            rejected: session.rejected.rows.length,
+        };
+    };
+    /** The saved mappings the user sees for `model`, and the templates installed modules ship for it. */
+    const mappingsFor = async (env, model) => {
+        const templates = context.registry.loaded.modules.flatMap((m) => (m.importTemplates ?? [])
+            .filter((t) => t.model === model)
+            .map((t) => ({
+            id: `${m.name}.${t.key}`,
+            name: t.label,
+            model,
+            template: true,
+            shared: true,
+            own: false,
+            columns: t.columns,
+            options: parseOptions(t.options),
+        })));
+        const keys = ['name', 'user', 'shared', 'columns', 'options'];
+        const found = await ref(env, 'import.mapping').search({ where: { resModel: model } });
+        const saved = (await found.load(keys)).read(keys).map((row) => ({
+            id: String(row['id']),
+            name: String(row['name']),
+            model,
+            template: false,
+            shared: row['shared'] === true,
+            own: row['user'] === env.uid,
+            columns: row['columns'] ?? [],
+            options: row['options'] ?? {},
+        }));
+        return [...templates, ...saved];
+    };
+    /** The mapping whose every header the file has, the one with the most columns; null when none fits. */
+    const fitting = (mappings, headers) => {
+        const present = new Set(headers.map(normalize));
+        let best = null;
+        for (const m of mappings)
+            if (m.columns.length > 0 &&
+                m.columns.every((c) => present.has(normalize(c.header))) &&
+                (best === null || m.columns.length > best.columns.length))
+                best = m;
+        return best;
+    };
+    /** The columns of a file under a saved mapping: by header; fields the user may not import are left out. */
+    const applyMapping = (mapping, headers, fields) => {
+        const byHeader = new Map(mapping.columns.map((c) => [normalize(c.header), c.field]));
+        const taken = new Set();
+        return headers.map((header, index) => {
+            const field = byHeader.get(normalize(header)) ?? null;
+            if (field === null ||
+                taken.has(field) ||
+                !fields.has(field) ||
+                fields.get(field)?.kind === 'one2many')
+                return { index, header, field: null };
+            taken.add(field);
+            return { index, header, field };
+        });
+    };
+    /** Runs the session's import (or its dry run) as `env`'s user, with the checks of its mode. */
+    const execute = async (env, session, dryRun, onProgress) => {
+        const mode = session.options.mode ?? 'create';
+        if (mode !== 'update')
+            env.access.check(session.model.name, 'create');
+        if (mode !== 'create')
+            env.access.check(session.model.name, 'write');
+        const table = readTable(session.file, session.fileType, session.sheet);
+        return runImport(env, session.model, fieldsOf(env, session.model), table, session.columns, {
+            ...session.options,
+            dryRun,
+            ...(onProgress === undefined ? {} : { onProgress }),
+        });
+    };
+    /** Records the outcome of a run on the session; a kept import is announced and audited. */
+    const record = async (env, session, result, dryRun, ip) => {
+        const view = shown(result);
+        if (dryRun || result.undo === null) {
+            await session.rows.write({ state: 'draft', result: view, resultDry: dryRun, failure: null });
+            return;
+        }
+        await session.rows.write({
+            state: 'done',
+            createdIds: [...result.created],
+            undo: result.undo,
+            rejected: { errors: [...result.errors], rows: [...result.rejectedRows] },
+            importedAt: new Date(),
+            result: view,
+            resultDry: false,
+            failure: null,
+        });
+        if (result.created.length > 0)
+            announceChange(env, driver, {
+                model: session.model.name,
+                ids: [...result.created],
+                op: 'create',
+            });
+        if (result.updated.length > 0)
+            announceChange(env, driver, {
+                model: session.model.name,
+                ids: [...result.updated],
+                op: 'update',
+            });
+        await audit(env, {
+            kind: 'data.import',
+            summary: `Imported ${session.fileName} into ${session.model.name}: ${result.created.length} created, ${result.updated.length} updated, ${result.skipped} left out.`,
+            targetModel: session.model.name,
+            details: {
+                created: result.created.length,
+                updated: result.updated.length,
+                skipped: result.skipped,
+                file: session.fileName,
+                session: session.id,
+            },
+            ...(ip === undefined ? {} : { ip }),
+        });
+    };
+    return {
+        inlineRows,
+        catalog,
+        guard,
+        modelFor,
+        fieldsOf,
+        columnFields,
+        sessionOf,
+        progressOf,
+        startProgress,
+        reportProgress,
+        describe,
+        mappingsFor,
+        fitting,
+        applyMapping,
+        execute,
+        record,
+    };
+}

package/dist/import/web/ImportButton.d.ts

@@ -0,0 +1,7 @@
+/**
+ * "Import" next to every list's "New" (RFC 0014 §5.8): shown when the user may import into the model and the import
+ * module answers; it opens the import screen.
+ */
+import { type CreateAssistProps } from '../../ui/index.js';
+import { type ReactElement } from 'react';
+export declare function ImportButton({ api, model }: CreateAssistProps): ReactElement | null;

package/dist/import/web/ImportButton.js

@@ -0,0 +1,31 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * "Import" next to every list's "New" (RFC 0014 §5.8): shown when the user may import into the model and the import
+ * module answers; it opens the import screen.
+ */
+import { Button } from '../../ui/index.js';
+import { useQuery } from '@tanstack/react-query';
+import { Upload } from 'lucide-react';
+import { useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import { ImportWizard } from './ImportWizard.js';
+export function ImportButton({ api, model }) {
+    const { t } = useTranslation('import');
+    const [open, setOpen] = useState(false);
+    const meta = useQuery({
+        queryKey: ['meta', model],
+        queryFn: () => api.meta(model),
+        staleTime: 60_000,
+    });
+    // The import module may not be installed, or the user may lack Import data: then the button stays hidden.
+    const available = useQuery({
+        queryKey: ['import', 'mappings', model],
+        queryFn: () => api.call('GET', `/api/v1/import-mappings?model=${encodeURIComponent(model)}`),
+        enabled: meta.data?.operations.import === true,
+        retry: false,
+        staleTime: 60_000,
+    });
+    if (meta.data?.operations.import !== true || available.data === undefined)
+        return null;
+    return (_jsxs(_Fragment, { children: [_jsxs(Button, { size: "sm", variant: "secondary", onClick: () => setOpen(true), children: [_jsx(Upload, { "aria-hidden": true }), t('import')] }), _jsx(ImportWizard, { api: api, model: model, open: open, onOpenChange: setOpen })] }));
+}

package/dist/import/web/ImportWizard.d.ts

@@ -0,0 +1,75 @@
+/**
+ * The import screen (RFC 0014 §5.8): three steps in a wide dialog. The file (with a sample workbook to start from);
+ * the columns (each with its first values and the field it fills, the mode and key, what to do with errors, saved
+ * mappings); the result (counts, the errors with their row and column, the rejected rows, undo). Large files run
+ * in the background and the dialog follows their progress. The server reads, converts and checks everything; the
+ * screen only shows what it says.
+ */
+import { type KoshApi } from '../../ui/index.js';
+import { type ReactElement } from 'react';
+interface Field {
+    readonly key: string;
+    readonly kind: string;
+    readonly label: string;
+    readonly required: boolean;
+    readonly keyable: boolean;
+    readonly line?: string;
+}
+interface Options {
+    readonly mode?: 'create' | 'update' | 'upsert';
+    readonly key?: string;
+    readonly onError?: 'stop' | 'skip';
+    readonly dateOrder?: 'dmy' | 'mdy' | 'ymd';
+    readonly decimal?: '.' | ',';
+}
+interface RowError {
+    readonly row: number;
+    readonly column: number | null;
+    readonly code: string;
+    readonly message: string;
+}
+interface Result {
+    readonly rows: number;
+    readonly created: readonly number[];
+    readonly updated: readonly number[];
+    readonly wouldCreate: number;
+    readonly wouldUpdate: number;
+    readonly skipped: number;
+    readonly errors: readonly RowError[];
+}
+export interface ImportSession {
+    readonly id: number;
+    readonly model: string;
+    readonly fileName: string;
+    readonly state: 'draft' | 'running' | 'done' | 'undone';
+    readonly rowCount: number;
+    readonly background: boolean;
+    readonly headers: readonly string[];
+    readonly sample: readonly (readonly unknown[])[];
+    readonly columns: readonly {
+        readonly index: number;
+        readonly field: string | null;
+    }[];
+    readonly options: Options;
+    readonly fields: readonly Field[];
+    readonly progress: {
+        readonly done: number;
+        readonly total: number;
+    } | null;
+    readonly result: Result | null;
+    readonly resultDry: boolean;
+    readonly failure: string | null;
+    readonly undoUntil: string | null;
+    readonly rejected: number;
+    readonly applied?: {
+        readonly id: string;
+        readonly name: string;
+    } | null;
+}
+export declare function ImportWizard({ api, model, open, onOpenChange, }: {
+    readonly api: KoshApi;
+    readonly model: string;
+    readonly open: boolean;
+    readonly onOpenChange: (open: boolean) => void;
+}): ReactElement;
+export {};