kviewer 0.2.0 → 0.2.2

package/dist/runtime/composables/usePageVirtualization.js

@@ -5,6 +5,30 @@ export function createPageVirtualization() {
   const pageMetas = shallowRef([]);
   const currentPage = ref(1);
   const visiblePages = shallowRef(/* @__PURE__ */ new Set());
+  const viewedPages = shallowRef(/* @__PURE__ */ new Set());
+  const allPagesRead = computed(() => {
+    const total = pageMetas.value.length;
+    return total > 0 && viewedPages.value.size >= total;
+  });
+  function markPageViewed(pageNumber) {
+    if (viewedPages.value.has(pageNumber)) return;
+    const next = new Set(viewedPages.value);
+    next.add(pageNumber);
+    viewedPages.value = next;
+  }
+  function markPagesViewed(pageNumbers) {
+    let next = null;
+    for (const n of pageNumbers) {
+      if (viewedPages.value.has(n) || next?.has(n)) continue;
+      if (!next) next = new Set(viewedPages.value);
+      next.add(n);
+    }
+    if (next) viewedPages.value = next;
+  }
+  function resetViewedPages() {
+    if (viewedPages.value.size === 0) return;
+    viewedPages.value = /* @__PURE__ */ new Set();
+  }
   let observer = null;
   let scrollRoot = null;
   let scrollListener = null;
@@ -88,12 +112,19 @@ export function createPageVirtualization() {
     if (bestPage !== currentPage.value) {
       currentPage.value = bestPage;
     }
+    const viewportBottom = rootTop + scrollRoot.clientHeight;
+    const reached = [];
+    for (const [pageNum, el] of pageToElement) {
+      if (el.offsetTop < viewportBottom) reached.push(pageNum);
+    }
+    markPagesViewed(reached);
   }
   function scrollToPage(pageNumber) {
     const element = pageToElement.get(pageNumber);
     if (element && scrollRoot) {
       element.scrollIntoView({ block: "start", behavior: "instant" });
       currentPage.value = pageNumber;
+      markPageViewed(pageNumber);
     }
   }
   function getPageElement(pageNumber) {
@@ -103,8 +134,10 @@ export function createPageVirtualization() {
     if (!scrollRoot) return;
     const rootRect = scrollRoot.getBoundingClientRect();
     const rootMid = rootRect.top + rootRect.height / 2;
+    const rootBottom = rootRect.top + rootRect.height;
     let bestPage = currentPage.value;
     let bestDist = Infinity;
+    const reached = [];
     for (const [pageNum, el] of pageToElement) {
       const rect = el.getBoundingClientRect();
       const dist = rootMid < rect.top ? rect.top - rootMid : rootMid > rect.bottom ? rootMid - rect.bottom : 0;
@@ -112,7 +145,9 @@ export function createPageVirtualization() {
         bestDist = dist;
         bestPage = pageNum;
       }
+      if (rect.top < rootBottom) reached.push(pageNum);
     }
+    markPagesViewed(reached);
     if (bestPage !== currentPage.value) {
       currentPage.value = bestPage;
     }
@@ -221,6 +256,7 @@ export function createPageVirtualization() {
     elementToPage.clear();
     pageToElement.clear();
     visiblePages.value = /* @__PURE__ */ new Set();
+    viewedPages.value = /* @__PURE__ */ new Set();
     pageMetas.value = [];
     scrollRoot = null;
   }
@@ -228,6 +264,10 @@ export function createPageVirtualization() {
     pageMetas,
     currentPage,
     renderedPages,
+    viewedPages,
+    allPagesRead,
+    markPageViewed,
+    resetViewedPages,
     isPageRendered,
     observePage,
     unobservePage,

package/dist/runtime/composables/useScriptingManager.d.ts

@@ -2,7 +2,9 @@ import type { PDFDocumentProxy, PDFPageProxy } from 'pdfjs-dist';
 import type { Ref } from 'vue';
 /** Minimal viewer surface PDFScriptingManager calls into. The official
  *  PDFViewer is large; we mock the slice the manager actually touches
- *  (verified in pdfjs-dist/web/pdf_viewer.mjs lines 7548-7691 and 7639). */
+ *  (verified against the `PDFScriptingManager` class in
+ *  pdfjs-dist/web/pdf_viewer.mjs — `setDocument`, `#dispatchPageOpen`,
+ *  and the `updatefromsandbox` handler). */
 export interface ScriptingViewerAdapter {
     currentPageNumber: number;
     pagesCount: number;
@@ -39,7 +41,8 @@ export interface ScriptingManager {
     /** Pump a user-interaction event into the sandbox for a given field. */
     dispatchFieldEvent: (fieldId: string, name: 'Action' | 'Validate' | 'Focus' | 'Blur' | 'Mouse Up' | 'Mouse Down' | 'Mouse Enter' | 'Mouse Exit' | 'Keystroke', value: string | boolean | string[], extra?: Record<string, unknown>) => void;
     /** Notify the sandbox that a page finished rendering, so any deferred
-     *  PageOpen action can fire (pdf_viewer.mjs:7441). */
+     *  PageOpen action can fire (the manager's `updatefromsandbox` /
+     *  pagerendered handling in pdf_viewer.mjs). */
     notifyPageRendered: (pageNumber: number) => void;
     /** Bind a document to the sandbox. Safe to call repeatedly — pass
      *  null to detach (e.g. before swapping documents). */
@@ -53,8 +56,9 @@ export interface ScriptingManager {
 /** Construct the scripting manager. ONE instance per `<Viewer>` lifetime —
  *  reuse `setDocument(null)` then `setDocument(newDoc)` across document
  *  swaps. PDFScriptingManagerComponents attaches a window-level
- *  `updatefromsandbox` listener in its constructor (pdf_viewer.mjs:7733)
- *  with no removal path; constructing it per-document would leak. */
+ *  `updatefromsandbox` listener in its constructor (when no
+ *  `externalServices` is supplied) with no removal path; constructing it
+ *  per-document would leak. */
 export declare function createScriptingManager(deps: ScriptingManagerDeps): Promise<ScriptingManager>;
 /** Cast helper used by the bridge — keeps the eventBus access narrowly
  *  typed without exporting an extra interface. */

package/dist/runtime/composables/useScriptingManager.js

@@ -18,6 +18,7 @@ export async function createScriptingManager(deps) {
   };
   window.addEventListener("updatefromsandbox", onSandboxWindowEvent);
   const sandboxBundleSrc = new URL("/_kviewer/pdfjs/pdf.sandbox.mjs", window.location.origin).href;
+  const wasmUrl = new URL("/_kviewer/wasm/", window.location.origin).href;
   const adapter = {
     get currentPageNumber() {
       return deps.viewerState.currentPage.value;
@@ -70,6 +71,7 @@ export async function createScriptingManager(deps) {
   const manager = new PDFScriptingManager({
     eventBus,
     sandboxBundleSrc,
+    wasmUrl,
     // Required: PDFScriptingManager passes the result into the sandbox's
     // docInfo. The official viewer assembles a rich metadata blob; we
     // provide the minimum the sandbox needs to boot. Fields are read by

package/dist/runtime/composables/useViewerState.d.ts

@@ -65,6 +65,10 @@ export interface ViewerStateProvider {
     state: ViewerState;
     setScrollToPageFn: (fn: (pageNumber: number) => void) => void;
     setDownloadPdfFn: (fn: () => Promise<void>) => void;
+    /** Register how custom-scale changes are applied. The Viewer registers a
+     *  position-preserving commit (zoom about the viewport centre); without
+     *  one, setScale falls back to a plain scale write. */
+    setApplyScaleFn: (fn: (value: number) => void) => void;
 }
 export declare function provideViewerState(): ViewerStateProvider;
 export declare function useViewerState(): ViewerState;

package/dist/runtime/composables/useViewerState.js

@@ -41,7 +41,12 @@ export function provideViewerState() {
   function setFitMode(mode) {
     fitMode.value = mode;
   }
+  let _applyScaleFn = null;
   function setScale(value) {
+    if (_applyScaleFn) {
+      _applyScaleFn(value);
+      return;
+    }
     fitMode.value = "custom";
     scale.value = value;
   }
@@ -212,6 +217,9 @@ export function provideViewerState() {
     },
     setDownloadPdfFn(fn) {
       _downloadPdfFn = fn;
+    },
+    setApplyScaleFn(fn) {
+      _applyScaleFn = fn;
     }
   };
 }

package/dist/runtime/embed/bridge-client.d.ts

@@ -20,7 +20,8 @@ type EventHandler<E extends EventName> = (payload: EventPayloads[E]) => void;
  * Parent-page client that drives a `<KViewer>` instance running inside
  * an iframe. Wraps `postMessage` into a Promise-based RPC mirroring the
  * viewer's exposed methods, and surfaces iframe-emitted events
- * (`ready`, `formEditMode-changed`) via `on()`.
+ * (`ready`, `formEditMode-changed`, `viewedPages-changed`, `all-pages-read`)
+ * via `on()`.
  */
 export declare class KViewerEmbedClient {
     private readonly iframe;
@@ -52,6 +53,13 @@ export declare class KViewerEmbedClient {
     getFormEditMode(): Promise<boolean>;
     setFormEditMode(enabled: boolean): Promise<void>;
     toggleFormEditMode(): Promise<boolean>;
+    /** True once the user has viewed every page. For a push-style signal,
+     *  subscribe via `on('all-pages-read', …)` / `on('viewedPages-changed', …)`. */
+    allPagesRead(): Promise<boolean>;
+    /** Page numbers viewed so far, ascending. */
+    getViewedPages(): Promise<number[]>;
+    /** Clear viewed-page tracking, e.g. to restart a signing session. */
+    resetViewedPages(): Promise<void>;
     private call;
     private handleMessage;
 }

package/dist/runtime/embed/bridge-client.js

@@ -87,6 +87,19 @@ export class KViewerEmbedClient {
   toggleFormEditMode() {
     return this.call("toggleFormEditMode");
   }
+  /** True once the user has viewed every page. For a push-style signal,
+   *  subscribe via `on('all-pages-read', …)` / `on('viewedPages-changed', …)`. */
+  allPagesRead() {
+    return this.call("allPagesRead");
+  }
+  /** Page numbers viewed so far, ascending. */
+  getViewedPages() {
+    return this.call("getViewedPages");
+  }
+  /** Clear viewed-page tracking, e.g. to restart a signing session. */
+  resetViewedPages() {
+    return this.call("resetViewedPages");
+  }
   // ── internals ──────────────────────────────────────────────────────────
   call(method, ...args) {
     if (this.disposed) {

package/dist/runtime/embed/bridge-host.d.ts

@@ -26,6 +26,9 @@ export interface KViewerApi {
     formEditMode: Ref<boolean>;
     setFormEditMode: (enabled: boolean) => void;
     toggleFormEditMode: () => boolean;
+    allPagesRead: () => boolean;
+    getViewedPages: () => number[];
+    resetViewedPages: () => void;
 }
 export interface KViewerEmbedBridgeOptions {
     /**

package/dist/runtime/embed/bridge-host.js

@@ -75,6 +75,13 @@ export function useKViewerEmbedBridge(viewerRef, options) {
       }
       case "toggleFormEditMode":
         return viewer.toggleFormEditMode();
+      case "allPagesRead":
+        return viewer.allPagesRead();
+      case "getViewedPages":
+        return viewer.getViewedPages();
+      case "resetViewedPages":
+        viewer.resetViewedPages();
+        return void 0;
       default:
         throw new Error(`Unknown KViewer embed method: ${req.method}`);
     }
@@ -110,17 +117,32 @@ export function useKViewerEmbedBridge(viewerRef, options) {
     target.postMessage(reply, event.origin === "" ? options.parentOrigin : event.origin);
   }
   win.addEventListener("message", handleMessage);
-  let stopFormEditWatch = null;
+  let stopViewerStateWatches = [];
   const stopViewerWatch = watch(
     viewerRef,
     (viewer) => {
-      stopFormEditWatch?.();
-      stopFormEditWatch = null;
+      for (const stop of stopViewerStateWatches) stop();
+      stopViewerStateWatches = [];
       if (!viewer) return;
       postEvent("ready", { protocolVersion: KVIEWER_EMBED_PROTOCOL_VERSION });
-      stopFormEditWatch = watch(
-        viewer.formEditMode,
-        (enabled) => postEvent("formEditMode-changed", { enabled })
+      stopViewerStateWatches.push(
+        watch(
+          viewer.formEditMode,
+          (enabled) => postEvent("formEditMode-changed", { enabled })
+        ),
+        // Read-tracking. The getters touch the viewer's reactive viewed-pages
+        // state, so watch re-runs them whenever a page is viewed or tracking
+        // is reset.
+        watch(
+          () => viewer.allPagesRead(),
+          (read, prev) => {
+            if (read && !prev) postEvent("all-pages-read", {});
+          }
+        ),
+        watch(
+          () => viewer.getViewedPages(),
+          (pages) => postEvent("viewedPages-changed", { pages, allRead: viewer.allPagesRead() })
+        )
       );
     },
     { immediate: true }
@@ -128,8 +150,8 @@ export function useKViewerEmbedBridge(viewerRef, options) {
   function unmount() {
     win.removeEventListener("message", handleMessage);
     stopViewerWatch();
-    stopFormEditWatch?.();
-    stopFormEditWatch = null;
+    for (const stop of stopViewerStateWatches) stop();
+    stopViewerStateWatches = [];
   }
   onScopeDispose(unmount);
   return { unmount };

package/dist/runtime/embed/protocol.d.ts

@@ -59,6 +59,18 @@ export interface MethodSignatures {
         args: [];
         result: boolean;
     };
+    allPagesRead: {
+        args: [];
+        result: boolean;
+    };
+    getViewedPages: {
+        args: [];
+        result: number[];
+    };
+    resetViewedPages: {
+        args: [];
+        result: undefined;
+    };
 }
 export type MethodName = keyof MethodSignatures;
 export interface RequestMessage<M extends MethodName = MethodName> {
@@ -91,6 +103,15 @@ export interface EventPayloads {
     'formEditMode-changed': {
         enabled: boolean;
     };
+    /** The set of viewed pages changed. `allRead` is true once every page has
+     *  been viewed. */
+    'viewedPages-changed': {
+        pages: number[];
+        allRead: boolean;
+    };
+    /** Fires once when the final unseen page is viewed. Re-arms after
+     *  `resetViewedPages()` or a new document. */
+    'all-pages-read': Record<string, never>;
 }
 export type EventName = keyof EventPayloads;
 export interface EventMessage<E extends EventName = EventName> {

package/dist/runtime/i18n/messages.d.ts

@@ -0,0 +1,252 @@
+/**
+ * Built-in UI message catalog.
+ *
+ * kviewer is consumed both as a Nuxt module (wrench) and through the
+ * iframe embed bridge by non-Nuxt hosts (esign/React), so it cannot
+ * depend on a host i18n library. The catalog is intentionally tiny:
+ * locale comes from the Viewer `locale` prop (or the module option),
+ * and hosts may override individual strings via the `messages` prop.
+ */
+export declare const messages: {
+    readonly en: {
+        readonly cancel: "Cancel";
+        readonly ok: "OK";
+        readonly save: "Save";
+        readonly clear: "Clear";
+        readonly delete: "Delete";
+        readonly download: "Download";
+        readonly search: "Search";
+        readonly marqueeSelect: "Marquee select";
+        readonly eraser: "Eraser";
+        readonly color: "Color";
+        readonly editText: "Edit text";
+        readonly strokeWidth: "Stroke width";
+        readonly decreaseStrokeWidth: "Decrease stroke width";
+        readonly increaseStrokeWidth: "Increase stroke width";
+        readonly noProperties: "No properties";
+        readonly detectFormFields: "Detect form fields";
+        readonly disableFormFieldDetection: "Disable form field detection";
+        readonly fitWidth: "Fit width";
+        readonly fitPage: "Fit page";
+        readonly stamp: "Stamp";
+        readonly signature: "Signature";
+        readonly searchPlaceholder: "Find in document...";
+        readonly previousMatch: "Previous match";
+        readonly nextMatch: "Next match";
+        readonly matchCase: "Match case";
+        readonly wholeWord: "Whole word";
+        readonly highlightAll: "Highlight all";
+        readonly closeSearch: "Close search";
+        readonly noResults: "No results";
+        readonly typeToSearch: "Type to search";
+        readonly freeText: "Free text";
+        readonly startTyping: "Start typing...";
+        readonly drawSignature: "Draw signature";
+        readonly noSavedSignatures: "No saved signatures";
+        readonly addSignature: "Add signature";
+        readonly selectedCount: "{count} selected";
+        readonly pageTransition: "Page transition";
+        readonly continuous: "Continuous";
+        readonly pageByPage: "Page by page";
+        readonly rotate: "Rotate";
+        readonly rotateClockwise: "Clockwise";
+        readonly rotateCounterclockwise: "Counterclockwise";
+        readonly layout: "Layout";
+        readonly singlePage: "Single page";
+        readonly twoPages: "Two pages";
+        readonly stylusMode: "Stylus mode";
+        readonly fullscreen: "Fullscreen";
+        readonly fieldProperties: "Field properties";
+        readonly fieldName: "Field name";
+        readonly fieldNameHint: "Shared names group radio buttons and bind multiple widgets to the same value.";
+        readonly required: "Required";
+        readonly readOnly: "Read-only";
+        readonly multiLine: "Multi-line";
+        readonly maxLength: "Max length";
+        readonly noLimit: "No limit";
+        readonly style: "Style";
+        readonly checkboxStyleHint: "Glyph drawn when checked. Saved as /MK /CA on export.";
+        readonly options: "Options";
+        readonly optionLabelPlaceholder: "Label";
+        readonly addOption: "Add option";
+        readonly comboBox: "Combo box (collapsible)";
+        readonly allowCustomText: "Allow custom text";
+        readonly multiSelect: "Multi-select";
+        readonly promptText: "Prompt text";
+        readonly clickToSign: "Click to sign";
+        readonly promptTextHint: "Shown on the unsigned widget. Defaults to \"{default}\".";
+        readonly lockFieldsAfterSigning: "Lock fields after signing";
+        readonly lockFieldsHint: "Once this signature is filled, listed fields become read-only inside the viewer. Not preserved on PDF export.";
+        readonly lockNone: "None";
+        readonly lockAllOther: "All other fields";
+        readonly lockSelectedOnly: "Selected fields only";
+        readonly lockAllExceptSelected: "All except selected";
+        readonly lockTheseFields: "Lock these fields";
+        readonly lockAllFieldsExcept: "Lock all fields except";
+        readonly noOtherNamedFields: "No other named fields in the document.";
+        readonly group: "Group";
+        readonly newGroup: "+ New group";
+        readonly radioGroupHint: "Radios sharing a group act as one — picking one clears the others.";
+        readonly optionValue: "Option value";
+        readonly optionValueHint: "Value stored when this option is selected. Must be unique inside the group.";
+        readonly typeLabel: "Type";
+        readonly pageLabel: "Page";
+        readonly deleteField: "Delete field";
+        readonly selectFieldHint: "Select a placed field to edit its properties.";
+        readonly fieldTypeText: "Text field";
+        readonly fieldTypeCheckbox: "Checkbox";
+        readonly fieldTypeRadio: "Radio button";
+        readonly fieldTypeSignature: "Signature field";
+        readonly fieldTypeDropdown: "Dropdown";
+        readonly fieldTypeButton: "Button";
+        readonly fieldTypeGeneric: "Field";
+        readonly fieldOnPage: "{type} on page {page}";
+        readonly styleCheck: "Check";
+        readonly styleCross: "Cross";
+        readonly styleDiamond: "Diamond";
+        readonly styleCircle: "Circle";
+        readonly styleStar: "Star";
+        readonly styleSquare: "Square";
+        readonly toolSelect: "Select";
+        readonly toolHighlight: "Highlight";
+        readonly toolStrikeout: "Strike out";
+        readonly toolUnderline: "Underline";
+        readonly toolRectangle: "Rectangle";
+        readonly toolCircle: "Ellipse";
+        readonly toolNote: "Note";
+        readonly toolArrow: "Arrow";
+        readonly toolCloud: "Cloud";
+        readonly toolFreehand: "Pen";
+        readonly toolFreeHighlight: "Highlighter";
+        readonly toolFreeText: "Text";
+        readonly toolSignature: "Signature";
+        readonly toolStamp: "Stamp";
+        readonly toolFormText: "Text field";
+        readonly toolFormCheckbox: "Checkbox";
+        readonly toolFormSignature: "Signature field";
+        readonly toolFormRadio: "Radio button";
+        readonly toolEraser: "Eraser";
+    };
+    readonly de: {
+        readonly cancel: "Abbrechen";
+        readonly ok: "OK";
+        readonly save: "Speichern";
+        readonly clear: "Leeren";
+        readonly delete: "Löschen";
+        readonly download: "Herunterladen";
+        readonly search: "Suchen";
+        readonly marqueeSelect: "Mehrfachauswahl";
+        readonly eraser: "Radierer";
+        readonly color: "Farbe";
+        readonly editText: "Text bearbeiten";
+        readonly strokeWidth: "Linienstärke";
+        readonly decreaseStrokeWidth: "Linienstärke verringern";
+        readonly increaseStrokeWidth: "Linienstärke erhöhen";
+        readonly noProperties: "Keine Eigenschaften";
+        readonly detectFormFields: "Formularfelder erkennen";
+        readonly disableFormFieldDetection: "Formularfeld-Erkennung deaktivieren";
+        readonly fitWidth: "Seitenbreite";
+        readonly fitPage: "Ganze Seite";
+        readonly stamp: "Stempel";
+        readonly signature: "Unterschrift";
+        readonly searchPlaceholder: "Im Dokument suchen...";
+        readonly previousMatch: "Vorheriger Treffer";
+        readonly nextMatch: "Nächster Treffer";
+        readonly matchCase: "Groß-/Kleinschreibung";
+        readonly wholeWord: "Ganzes Wort";
+        readonly highlightAll: "Alle hervorheben";
+        readonly closeSearch: "Suche schließen";
+        readonly noResults: "Keine Treffer";
+        readonly typeToSearch: "Suchbegriff eingeben";
+        readonly freeText: "Freitext";
+        readonly startTyping: "Text eingeben...";
+        readonly drawSignature: "Unterschrift zeichnen";
+        readonly noSavedSignatures: "Keine gespeicherten Unterschriften";
+        readonly addSignature: "Unterschrift hinzufügen";
+        readonly selectedCount: "{count} ausgewählt";
+        readonly pageTransition: "Seitenübergang";
+        readonly continuous: "Fortlaufend";
+        readonly pageByPage: "Seite für Seite";
+        readonly rotate: "Drehen";
+        readonly rotateClockwise: "Im Uhrzeigersinn";
+        readonly rotateCounterclockwise: "Gegen den Uhrzeigersinn";
+        readonly layout: "Layout";
+        readonly singlePage: "Einseitig";
+        readonly twoPages: "Zweiseitig";
+        readonly stylusMode: "Stiftmodus";
+        readonly fullscreen: "Vollbildansicht";
+        readonly fieldProperties: "Feldeigenschaften";
+        readonly fieldName: "Feldname";
+        readonly fieldNameHint: "Gleiche Namen gruppieren Optionsfelder und verbinden mehrere Widgets mit demselben Wert.";
+        readonly required: "Pflichtfeld";
+        readonly readOnly: "Schreibgeschützt";
+        readonly multiLine: "Mehrzeilig";
+        readonly maxLength: "Maximale Länge";
+        readonly noLimit: "Kein Limit";
+        readonly style: "Stil";
+        readonly checkboxStyleHint: "Symbol im angekreuzten Zustand. Wird beim Export als /MK /CA gespeichert.";
+        readonly options: "Optionen";
+        readonly optionLabelPlaceholder: "Beschriftung";
+        readonly addOption: "Option hinzufügen";
+        readonly comboBox: "Kombinationsfeld (aufklappbar)";
+        readonly allowCustomText: "Eigenen Text erlauben";
+        readonly multiSelect: "Mehrfachauswahl";
+        readonly promptText: "Hinweistext";
+        readonly clickToSign: "Zum Unterschreiben klicken";
+        readonly promptTextHint: "Wird auf dem nicht unterschriebenen Feld angezeigt. Standard: \"{default}\".";
+        readonly lockFieldsAfterSigning: "Felder nach Unterschrift sperren";
+        readonly lockFieldsHint: "Sobald diese Unterschrift ausgefüllt ist, werden die gewählten Felder im Viewer schreibgeschützt. Wird beim PDF-Export nicht übernommen.";
+        readonly lockNone: "Keine";
+        readonly lockAllOther: "Alle anderen Felder";
+        readonly lockSelectedOnly: "Nur ausgewählte Felder";
+        readonly lockAllExceptSelected: "Alle außer ausgewählte";
+        readonly lockTheseFields: "Diese Felder sperren";
+        readonly lockAllFieldsExcept: "Alle Felder sperren außer";
+        readonly noOtherNamedFields: "Keine weiteren benannten Felder im Dokument.";
+        readonly group: "Gruppe";
+        readonly newGroup: "+ Neue Gruppe";
+        readonly radioGroupHint: "Optionsfelder derselben Gruppe wirken als eines — die Auswahl eines Feldes hebt die anderen auf.";
+        readonly optionValue: "Optionswert";
+        readonly optionValueHint: "Wert, der bei Auswahl dieser Option gespeichert wird. Muss innerhalb der Gruppe eindeutig sein.";
+        readonly typeLabel: "Typ";
+        readonly pageLabel: "Seite";
+        readonly deleteField: "Feld löschen";
+        readonly selectFieldHint: "Wählen Sie ein platziertes Feld aus, um seine Eigenschaften zu bearbeiten.";
+        readonly fieldTypeText: "Textfeld";
+        readonly fieldTypeCheckbox: "Kontrollkästchen";
+        readonly fieldTypeRadio: "Optionsfeld";
+        readonly fieldTypeSignature: "Unterschriftsfeld";
+        readonly fieldTypeDropdown: "Auswahlliste";
+        readonly fieldTypeButton: "Schaltfläche";
+        readonly fieldTypeGeneric: "Feld";
+        readonly fieldOnPage: "{type} auf Seite {page}";
+        readonly styleCheck: "Haken";
+        readonly styleCross: "Kreuz";
+        readonly styleDiamond: "Raute";
+        readonly styleCircle: "Kreis";
+        readonly styleStar: "Stern";
+        readonly styleSquare: "Quadrat";
+        readonly toolSelect: "Auswählen";
+        readonly toolHighlight: "Hervorheben";
+        readonly toolStrikeout: "Durchstreichen";
+        readonly toolUnderline: "Unterstreichen";
+        readonly toolRectangle: "Rechteck";
+        readonly toolCircle: "Ellipse";
+        readonly toolNote: "Notiz";
+        readonly toolArrow: "Pfeil";
+        readonly toolCloud: "Wolke";
+        readonly toolFreehand: "Stift";
+        readonly toolFreeHighlight: "Marker";
+        readonly toolFreeText: "Text";
+        readonly toolSignature: "Unterschrift";
+        readonly toolStamp: "Stempel";
+        readonly toolFormText: "Textfeld";
+        readonly toolFormCheckbox: "Kontrollkästchen";
+        readonly toolFormSignature: "Unterschriftsfeld";
+        readonly toolFormRadio: "Optionsfeld";
+        readonly toolEraser: "Radierer";
+    };
+};
+export type KviewerLocale = keyof typeof messages;
+export type MessageKey = keyof typeof messages.en;
+export declare const KVIEWER_LOCALES: KviewerLocale[];