@pretextbook/import 0.0.1 → 0.3.0

package/dist/index.js

@@ -1,90 +1,116 @@
-import { d as T, r as E, a as R, f as P, b as h, w as f, s as g, e as v, c as M, p as j } from "./import-mode-iBDd9oQY.js";
-import { L, M as U, g as z, h as O, i as N, j as W, k as B, l as X, m as q, n as G, o as H, q as J, t as Q, u as V, v as Y, x as Z, y as tt, z as et, A as nt } from "./import-mode-iBDd9oQY.js";
-function x() {
-  const t = globalThis.crypto;
-  return t?.randomUUID ? t.randomUUID() : "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (e) => {
-    const s = Math.random() * 16 | 0;
-    return (e === "x" ? s : s & 3 | 8).toString(16);
-  });
+import { d as $, r as j, a as k, f as P, b as h, w as g, s as b, e as A, c as C, p as v } from "./import-mode-DK83Lfue.js";
+import { L as O, M as W, g as U, h as X, i as q, j as H, k as Y, l as G, m as J, n as Q, o as V, q as Z, t as tt, u as et, v as nt, x as ot, y as at, z as it, A as st, B as rt, C as ct } from "./import-mode-DK83Lfue.js";
+const w = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  pdf: "application/pdf",
+  eps: "application/postscript",
+  ps: "application/postscript",
+  bmp: "image/bmp",
+  tiff: "image/tiff",
+  tif: "image/tiff",
+  webp: "image/webp",
+  ico: "image/vnd.microsoft.icon"
+};
+function R(t) {
+  const e = t.split(".").pop()?.toLowerCase() ?? "";
+  return w[e] ?? "application/octet-stream";
+}
+const f = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function M(t) {
+  const e = t.length, a = [];
+  for (let n = 0; n < e; n += 3) {
+    const o = t[n], s = n + 1 < e, c = n + 2 < e, r = s ? t[n + 1] : 0, l = c ? t[n + 2] : 0;
+    a.push(f[o >> 2]), a.push(f[(o & 3) << 4 | r >> 4]), a.push(s ? f[(r & 15) << 2 | l >> 6] : "="), a.push(c ? f[l & 63] : "=");
+  }
+  return a.join("");
+}
+function y(t) {
+  return {
+    ref: t.ref,
+    kind: "file",
+    title: t.fileName,
+    short_description: t.fileName,
+    file: {
+      filename: t.fileName,
+      content_type: R(t.fileName),
+      data: M(t.data)
+    }
+  };
 }
-function C(t) {
+function B(t) {
   return {
     title: t.title,
     docinfo: t.docinfo,
-    documentType: t.documentKind,
-    divisions: t.divisions.map((e) => ({
-      id: x(),
+    document_type: t.documentKind,
+    divisions_attributes: t.divisions.map((e) => ({
       ref: e.xmlId,
       source: e.content,
-      sourceFormat: e.sourceFormat,
-      isRoot: e.isRoot
+      source_format: e.sourceFormat,
+      is_root: e.isRoot
     })),
-    assets: t.assets.map((e) => ({
-      id: x(),
-      ref: e.ref,
-      kind: "file",
-      fileName: e.fileName,
-      data: e.data
-    }))
+    assets_attributes: t.assets.map(y)
   };
 }
-const p = {
+const d = {
   mainSourcePath: "source/main.ptx",
   publicationPath: "publication/publication.ptx",
   projectFilePath: "project.ptx",
   docinfoPath: "source/docinfo.ptx"
 };
-function b(t) {
+function x(t) {
   return P(t, "pretext") ? t : `<pretext>
 ${t}
 </pretext>`;
 }
-function F(t, e, s) {
-  const n = /* @__PURE__ */ new Map(), a = [], i = `${e}-`;
+function F(t, e, a) {
+  const n = /* @__PURE__ */ new Map(), o = [], s = `${e}-`;
   return t.forEach((c, r) => {
-    const u = c.attributes["xml:id"];
-    let l;
-    if (u) {
-      const m = M(u);
-      l = m.startsWith(i) ? m : `${i}${m}`;
+    const l = c.attributes["xml:id"];
+    let p;
+    if (l) {
+      const u = C(l);
+      p = u.startsWith(s) ? u : `${s}${u}`;
     } else
-      l = `${i}${j(r + 1, t.length)}`, s.push({
+      p = `${s}${v(r + 1, t.length)}`, a.push({
         action: "anomaly",
         severity: "info",
         kind: "structure",
         category: "missing_xml_id",
         macro: c.name,
         occurrences: 1,
-        message: `<${c.name}> at position ${r + 1} has no xml:id; using \`${l}\` as filename.`
+        message: `<${c.name}> at position ${r + 1} has no xml:id; using \`${p}\` as filename.`
       });
-    const d = n.get(l) ?? 0;
-    n.set(l, d + 1);
-    const o = d === 0 ? l : `${l}-${d + 1}`;
-    a.push({
+    const m = n.get(p) ?? 0;
+    n.set(p, m + 1);
+    const i = m === 0 ? p : `${p}-${m + 1}`;
+    o.push({
       span: c,
-      slug: o,
-      filename: `${o}.ptx`
+      slug: i,
+      filename: `${i}.ptx`
     });
-  }), a;
+  }), o;
 }
-function I(t, e, s, n) {
-  const a = h(t, "section");
-  if (a.length === 0)
+function I(t, e, a, n) {
+  const o = h(t, "section");
+  if (o.length === 0)
     return t;
-  const c = F(a, "sec", n).map((r) => {
-    const u = `source/${e}/${r.filename}`;
-    return s[u] = f(r.span.outer), {
+  const c = F(o, "sec", n).map((r) => {
+    const l = `source/${e}/${r.filename}`;
+    return a[l] = g(r.span.outer), {
       start: r.span.start,
       end: r.span.end,
       replacement: `<xi:include href="${e}/${r.filename}"/>`
     };
   });
-  return g(t, c);
+  return b(t, c);
 }
-function w(t, e, s) {
+function N(t, e, a) {
   const n = P(t, "book");
   if (!n)
-    return s.push({
+    return a.push({
       action: "anomaly",
       severity: "warning",
       kind: "structure",
@@ -92,73 +118,80 @@ function w(t, e, s) {
       macro: "book",
       occurrences: 1,
       message: "Document was treated as a book but no <book> element found; emitting as a single file."
-    }), $(t, e);
-  const a = {}, i = h(n.inner, "chapter");
+    }), S(t, e);
+  const o = {}, s = h(n.inner, "chapter");
   let c = n.inner;
-  if (e.splitChapters && i.length > 0) {
-    const d = F(i, "ch", s).map((o) => {
-      let m = o.span.outer;
+  if (e.splitChapters && s.length > 0) {
+    const m = F(s, "ch", a).map((i) => {
+      let u = i.span.outer;
       if (e.splitSections) {
-        const y = o.span.inner, S = I(y, o.slug, a, s);
-        m = o.span.outer.slice(0, o.span.startTagEnd - o.span.start) + S + o.span.outer.slice(o.span.contentEnd - o.span.start);
+        const E = i.span.inner, _ = I(
+          E,
+          i.slug,
+          o,
+          a
+        );
+        u = i.span.outer.slice(0, i.span.startTagEnd - i.span.start) + _ + i.span.outer.slice(i.span.contentEnd - i.span.start);
       }
-      const k = `source/${o.filename}`;
-      return a[k] = f(m), {
-        start: o.span.start,
-        end: o.span.end,
-        replacement: `<xi:include href="${o.filename}"/>`
+      const T = `source/${i.filename}`;
+      return o[T] = g(u), {
+        start: i.span.start,
+        end: i.span.end,
+        replacement: `<xi:include href="${i.filename}"/>`
       };
     });
-    c = g(n.inner, d);
+    c = b(n.inner, m);
   }
-  const r = t.slice(n.start, n.startTagEnd) + c + t.slice(n.contentEnd, n.end), u = t.slice(0, n.start) + r + t.slice(n.end);
-  return a[e.mainSourcePath] = f(
-    v(b(u.trim()))
-  ), a;
+  const r = t.slice(n.start, n.startTagEnd) + c + t.slice(n.contentEnd, n.end), l = t.slice(0, n.start) + r + t.slice(n.end);
+  return o[e.mainSourcePath] = g(
+    A(x(l.trim()))
+  ), o;
 }
-function $(t, e, s) {
+function S(t, e, a) {
   const n = {};
-  return n[e.mainSourcePath] = f(
-    b(t.trim())
+  return n[e.mainSourcePath] = g(
+    x(t.trim())
   ), n;
 }
 function D(t, e = {}) {
-  const s = [], n = e.documentKind ?? T(t), a = {
+  const a = [], n = e.documentKind ?? $(t), o = {
     splitChapters: e.splitChapters ?? n === "book",
     splitSections: e.splitSections ?? !1,
-    mainSourcePath: e.mainSourcePath ?? p.mainSourcePath,
-    publicationPath: e.publicationPath ?? p.publicationPath,
-    projectFilePath: e.projectFilePath ?? p.projectFilePath,
-    docinfoPath: e.docinfoPath ?? p.docinfoPath
-  }, i = n === "book" ? w(t, a, s) : $(t, a);
-  return i[a.projectFilePath] = E({
-    mainSource: a.mainSourcePath,
-    publication: a.publicationPath
-  }), i[a.publicationPath] = R(), { files: i, documentKind: n, warnings: s };
+    mainSourcePath: e.mainSourcePath ?? d.mainSourcePath,
+    publicationPath: e.publicationPath ?? d.publicationPath,
+    projectFilePath: e.projectFilePath ?? d.projectFilePath,
+    docinfoPath: e.docinfoPath ?? d.docinfoPath
+  }, s = n === "book" ? N(t, o, a) : S(t, o);
+  return s[o.projectFilePath] = j({
+    mainSource: o.mainSourcePath,
+    publication: o.publicationPath
+  }), s[o.publicationPath] = k(), { files: s, documentKind: n, warnings: a };
 }
 export {
-  L as LATEX_FORMAT_MARKERS,
-  U as MARKDOWN_FORMAT_MARKERS,
-  z as assetsForImportMode,
-  O as buildDivisionPool,
+  O as LATEX_FORMAT_MARKERS,
+  W as MARKDOWN_FORMAT_MARKERS,
+  U as assetsForImportMode,
+  X as buildDivisionPool,
+  q as buildNativeDivisionPool,
   D as buildPretextProjectFiles,
-  N as cleanLatex,
-  W as convertLatexToPretext,
-  B as convertMarkdownToPretext,
-  X as convertSourceToPretext,
-  T as detectDocumentKind,
-  q as detectSourceFormat,
-  G as divisionChildRefs,
-  H as expandPretextIncludes,
-  J as filesForImportMode,
-  Q as formatWarningLine,
-  V as getConversionErrorMessage,
-  Y as handleImportUploadFile,
-  Z as importProjectFromFiles,
-  tt as normalizePretextSource,
-  E as renderProjectPtx,
-  R as renderPublicationPtx,
-  et as sanitizeRef,
-  nt as serializeProjectToFiles,
-  C as serializeProjectToPlusPayload
+  H as cleanLatex,
+  Y as convertLatexToPretext,
+  G as convertMarkdownToPretext,
+  J as convertSourceToPretext,
+  $ as detectDocumentKind,
+  Q as detectSourceFormat,
+  V as divisionChildRefs,
+  Z as expandPretextIncludes,
+  tt as filesForImportMode,
+  et as formatWarningLine,
+  nt as getConversionErrorMessage,
+  ot as handleImportUploadFile,
+  at as importProjectFromFiles,
+  it as normalizePretextSource,
+  st as projectForImportMode,
+  j as renderProjectPtx,
+  k as renderPublicationPtx,
+  rt as sanitizeRef,
+  ct as serializeProjectToFiles,
+  B as serializeProjectToPlusPayload
 };

package/dist/lib/import-mode.d.ts

@@ -1,7 +1,15 @@
 import { CleaningWarning } from './clean/warnings';
-import { ImportedProjectSuccess } from './types';
+import { ImportedProject, ImportedProjectSuccess } from './types';
 /** Which of the result's alternatives the user chose to import. */
 export type ImportMode = "converted" | "native";
+/**
+ * The division pool the pretext-plus host should serialize for the chosen
+ * mode: the native (LaTeX/Markdown) pool when the user keeps the source
+ * format, otherwise the converted PreTeXt pool. Falls back to the converted
+ * pool when there is no native projection (e.g. PreTeXt input, or an import
+ * that produced no native source).
+ */
+export declare function projectForImportMode(result: ImportedProjectSuccess, mode: ImportMode): ImportedProject;
 /** The text files a host should write for the chosen mode. */
 export declare function filesForImportMode(result: ImportedProjectSuccess, mode: ImportMode): Record<string, string>;
 /** The binary assets a host should write for the chosen mode. */

package/dist/lib/pool/division-pool.d.ts

@@ -1,6 +1,7 @@
 import { CleaningWarning } from '../clean/warnings';
 import { DocumentKind } from '../layout/document-kind';
 import { ImportedProject } from '../types';
+export { sanitizeRef } from './refs';
 export interface BuildDivisionPoolOptions {
     documentKind?: DocumentKind;
     splitChapters?: boolean;
@@ -12,12 +13,6 @@ export interface BuildDivisionPoolResult {
     project: ImportedProject;
     warnings: CleaningWarning[];
 }
-/**
- * Coerce a string into a REF_REGEX-safe ref: invalid characters collapse to
- * `-`, leading characters that can't start a ref are stripped. Returns `""`
- * when nothing valid remains.
- */
-export declare function sanitizeRef(raw: string): string;
 /**
  * Parse a converted PreTeXt document
  * (`<pretext><docinfo>…</docinfo><book|article>…`) into the division pool.

package/dist/lib/pool/index.d.ts

@@ -1,3 +1,4 @@
 export { buildDivisionPool, sanitizeRef, type BuildDivisionPoolOptions, type BuildDivisionPoolResult, } from './division-pool';
+export { buildNativeDivisionPool, type BuildNativeDivisionPoolOptions, } from './native-pool';
 export { serializeProjectToFiles, divisionChildRefs, type SerializeProjectFilesOptions, type SerializedProjectFiles, } from './serialize-files';
 export { serializeProjectToPlusPayload } from './serialize-plus';

package/dist/lib/pool/native-pool.d.ts

@@ -0,0 +1,20 @@
+import { DocumentKind } from '../layout/document-kind';
+import { BuildDivisionPoolResult } from './division-pool';
+export interface BuildNativeDivisionPoolOptions {
+    documentKind?: DocumentKind;
+    splitChapters?: boolean;
+    splitSections?: boolean;
+    /** Project title, hoisted from the converted PreTeXt pool. */
+    title?: string;
+    /** Project `<docinfo>`, hoisted from the converted PreTeXt pool. */
+    docinfo?: string;
+    /** Binary assets keyed by their original (input) path. */
+    assets?: Record<string, Uint8Array>;
+}
+/**
+ * Build a native (LaTeX/Markdown) division pool from cleaned native source.
+ * The result has the same shape as `buildDivisionPool`, so the same
+ * serializers consume it — `serializeProjectToPlusPayload` in particular emits
+ * `source_format: "latex" | "markdown"` divisions unchanged.
+ */
+export declare function buildNativeDivisionPool(nativeSource: string, format: "latex" | "markdown", options?: BuildNativeDivisionPoolOptions): BuildDivisionPoolResult;

package/dist/lib/pool/refs.d.ts

@@ -0,0 +1,39 @@
+import { CleaningWarning } from '../clean/warnings';
+import { ImportedAsset } from '../types';
+/**
+ * Coerce a string into a REF_REGEX-safe ref: invalid characters collapse to
+ * `-`, leading characters that can't start a ref are stripped. Returns `""`
+ * when nothing valid remains.
+ */
+export declare function sanitizeRef(raw: string): string;
+/** Hands out refs, deduplicating with `-2`, `-3`, … suffixes. */
+export declare class RefPool {
+    private used;
+    claim(preferred: string): string;
+    has(ref: string): boolean;
+}
+export interface ClaimRefResult {
+    ref: string;
+    renamedFrom?: string;
+    generated: boolean;
+}
+/**
+ * Decide a division's ref from a raw id (an `xml:id`, a `\label`, or nothing):
+ * the existing id when REF_REGEX-safe and unused, a sanitized/deduplicated
+ * variant when not (reported as a rename), or a generated `fallback` when
+ * there was no id at all.
+ */
+export declare function claimRefFromId(rawId: string | undefined, refs: RefPool, fallback: string): ClaimRefResult;
+/**
+ * Record the structural warning implied by a ref claim: a rename when the
+ * original id was invalid or collided, an info note when an id was generated.
+ * `elementName` is the division's type (e.g. `chapter`); `position` is its
+ * 1-based index among its siblings, for the generated-id message.
+ */
+export declare function pushRefWarnings(warnings: CleaningWarning[], claim: ClaimRefResult, elementName: string, position: number): void;
+/**
+ * Turn a map of raw asset bytes (keyed by original input path) into
+ * `ImportedAsset` records, minting a ref from each basename's stem and
+ * deduplicating against everything already claimed (divisions included).
+ */
+export declare function buildAssets(rawAssets: Record<string, Uint8Array>, refs: RefPool): ImportedAsset[];

package/dist/lib/pool/serialize-plus.d.ts

@@ -1,10 +1,5 @@
 import { ImportedProject, PlusProjectPayload } from '../types';
 /**
- * Serialize the division pool to a pretext-plus project payload.
- *
- * The host page maps this onto the Rails endpoints (snake_case
- * `divisions_attributes` / `assets_attributes`, multipart for asset bytes);
- * note that `docinfo` currently requires a follow-up PATCH after create —
- * see SPEC §4.3 for the endpoint mapping and known gaps.
+ * Serialize the division pool to a pretext-plus import payload.
  */
 export declare function serializeProjectToPlusPayload(project: ImportedProject): PlusProjectPayload;

package/dist/lib/types.d.ts

@@ -70,35 +70,48 @@ export interface ImportedProject {
     divisions: ImportedDivision[];
     assets: ImportedAsset[];
 }
-/** One division row of the pretext-plus create/update payload (SPEC §4.3). */
-export interface PlusDivisionRecord {
-    /** Client-minted UUID; Rails inserts it as the record's primary key. */
-    id: string;
+/**
+ * One division row of the pretext-plus import payload (`divisions_attributes`
+ * on `POST /projects/import`). New rows only — `ProjectsController#import_params`
+ * permits no `id`/`_destroy` there (imports never edit or delete existing rows).
+ */
+export interface PlusDivisionAttributes {
     /** The division's `xml:id` (Rails column `ref`). */
     ref: string;
     source: string;
-    sourceFormat: SourceFormat;
-    isRoot: boolean;
+    source_format: SourceFormat;
+    is_root: boolean;
+}
+/**
+ * An asset's file upload. Bytes travel base64-encoded, since the whole import
+ * posts as one JSON body — `import_params` decodes `data` back into an
+ * ActiveStorage attachable server-side.
+ */
+export interface PlusAssetFile {
+    filename: string;
+    content_type: string;
+    data: string;
 }
-/** One asset row of the pretext-plus payload; bytes attach as `file`. */
-export interface PlusAssetRecord {
-    id: string;
+/** One asset row of the pretext-plus import payload (`assets_attributes`). */
+export interface PlusAssetAttributes {
     ref: string;
     kind: "file";
-    /** → `short_description` and the multipart upload filename. */
-    fileName: string;
-    data: Uint8Array;
+    title: string;
+    short_description: string;
+    file: PlusAssetFile;
 }
 /**
- * Direct camelCase mirror of what pretext-plus's `ProjectsController`
- * permits (`divisions_attributes` / `assets_attributes`) — see SPEC §4.3.
+ * Wire shape of `POST /projects/import`
+ * (`ProjectsController#create_from_import` / `import_params`) — a direct
+ * snake_case mirror, since the endpoint permits no `id` on either nested
+ * attribute.
  */
 export interface PlusProjectPayload {
     title: string;
     docinfo: string;
-    documentType: DocumentKind;
-    divisions: PlusDivisionRecord[];
-    assets: PlusAssetRecord[];
+    document_type: DocumentKind;
+    divisions_attributes: PlusDivisionAttributes[];
+    assets_attributes: PlusAssetAttributes[];
 }
 export interface ImportedProjectSuccess extends ConversionContext {
     pretextSource: string;
@@ -108,6 +121,14 @@ export interface ImportedProjectSuccess extends ConversionContext {
     documentKind: DocumentKind;
     /** Intermediate model of the imported project (SPEC §4.1). */
     project: ImportedProject;
+    /**
+     * Native-format (LaTeX/Markdown) projection of the same import, split into
+     * divisions joined by `\plus{…}{…}` / `::…{ref="…"}` placeholders (SPEC
+     * §4.3). Present only when the source was LaTeX or Markdown; the pretext-plus
+     * host serializes this instead of `project` when the user keeps the native
+     * format. `undefined` for PreTeXt input.
+     */
+    nativeProject?: ImportedProject;
     files: Record<string, string>;
     assets: Record<string, Uint8Array>;
     outputFiles: Record<string, string>;

package/dist/react/import-source-form.d.ts

@@ -17,4 +17,4 @@ export interface ImportSourceFormProps {
     disabled?: boolean;
     onImport: (result: ConvertedPretextResult) => void;
 }
-export declare function ImportSourceForm({ initialSource, initialSourceFormat, labels, disabled, onImport, }: ImportSourceFormProps): import("react/jsx-runtime").JSX.Element;
+export declare function ImportSourceForm({ initialSource, initialSourceFormat, labels, disabled, onImport, }: ImportSourceFormProps): import("react").JSX.Element;

package/dist/react/import-upload-panel.d.ts

@@ -18,4 +18,4 @@ export interface ImportUploadPanelProps {
     importOptions?: ImportProjectOptions;
     onImport: (result: ImportedProjectResult) => void;
 }
-export declare function ImportUploadPanel({ labels, disabled, defaultDocumentKind, importOptions, onImport, }: ImportUploadPanelProps): import("react/jsx-runtime").JSX.Element;
+export declare function ImportUploadPanel({ labels, disabled, defaultDocumentKind, importOptions, onImport, }: ImportUploadPanelProps): import("react").JSX.Element;

package/dist/react/import-wizard.d.ts

@@ -1,8 +1,26 @@
 import { ImportProjectOptions } from '../lib/upload';
 import { ImportMode } from '../lib/import-mode';
 import { DocumentKind } from '../lib/layout/document-kind';
-import { ImportedProjectSuccess } from '../lib/types';
+import { ImportedProjectResult, ImportedProjectSuccess } from '../lib/types';
 export type { ImportMode };
+/**
+ * A pluggable conversion engine. The wizard owns the whole UI (upload, review,
+ * preview, confirm) and only delegates the source → result step to the selected
+ * engine, so hosts can inject their own converters (e.g. a VS Code-only pandoc
+ * engine that round-trips to the extension host) without touching this package.
+ */
+export interface ImportEngine {
+    /** Stable identifier, used as the radio value. */
+    id: string;
+    /** Short name shown in the engine selector. */
+    label: string;
+    /** Optional one-line explanation shown under the label. */
+    description?: string;
+    /** Extensions this engine accepts (with leading dot). Defaults to the built-in set. */
+    acceptExtensions?: string[];
+    /** Convert an uploaded file into an import result. */
+    convertFile: (file: File, options: ImportProjectOptions) => Promise<ImportedProjectResult>;
+}
 export interface ImportWizardProps {
     /** Called when the user confirms the import. */
     onConfirm: (result: ImportedProjectSuccess, mode: ImportMode) => void;
@@ -11,5 +29,10 @@ export interface ImportWizardProps {
     /** Pass fixed options to skip the document-kind / split-sections controls. */
     importOptions?: ImportProjectOptions;
     defaultDocumentKind?: DocumentKind | "auto";
+    /**
+     * Converters offered to the user. When more than one is supplied, an engine
+     * selector is shown on the upload step. Defaults to a single built-in engine.
+     */
+    engines?: ImportEngine[];
 }
-export declare function ImportWizard({ onConfirm, onCancel, importOptions, defaultDocumentKind, }: ImportWizardProps): import("react/jsx-runtime").JSX.Element;
+export declare function ImportWizard({ onConfirm, onCancel, importOptions, defaultDocumentKind, engines, }: ImportWizardProps): import("react").JSX.Element;

package/dist/react/index.d.ts

@@ -1,5 +1,5 @@
 export { ImportWizard } from './import-wizard';
-export type { ImportWizardProps, ImportMode } from './import-wizard';
+export type { ImportWizardProps, ImportMode, ImportEngine, } from './import-wizard';
 export { ImportSourceForm } from './import-source-form';
 export { ImportUploadPanel } from './import-upload-panel';
 export type { ImportSourceFormProps, ImportSourceFormLabels, } from './import-source-form';