scanbot-web-sdk 6.0.0-dev.1 → 6.0.0-dev.2

package/@types/ui2/configuration/CameraPermission.d.ts

@@ -1,17 +1,11 @@
 import { ButtonConfiguration } from "./Common";
 import { DeepPartial, PartiallyConstructible } from "./utils";
 import { IconStyle } from "./Common";
-import { StatusBarMode } from "./TopBarConfiguration";
 import { StyledText } from "./Common";
 /**
  Configuration of the camera permission request view.
  */
 export declare class CameraPermissionScreen extends PartiallyConstructible {
-    /**
-     Visual mode for displaying the contents of the status bar.
-     @defaultValue "DARK";
-     */
-    statusBarMode: StatusBarMode;
     /**
      Background color of the camera permission request.
      @defaultValue "?sbColorSurface";
@@ -30,15 +24,6 @@ export declare class CameraPermissionScreen extends PartiallyConstructible {
       });
      */
     icon: IconStyle;
-    /**
-     Configuration of the camera permission request's confirmation button.
-     @defaultValue new ButtonConfiguration({
-        "text": "{'type': 'String', 'default': 'Grant permission'}",
-        "background": new BackgroundStyle({}),
-        "foreground": new ForegroundStyle({})
-    });
-     */
-    enableCameraButton: ButtonConfiguration;
     /**
      Configuration of the camera permission request's close button.
      @defaultValue new ButtonConfiguration({

package/@types/ui2/configuration/Common.d.ts

@@ -201,23 +201,6 @@ export declare class ForegroundStyle extends PartiallyConstructible {
     /** @param source {@displayType `DeepPartial<ForegroundStyle>`} */
     constructor(source?: DeepPartial<ForegroundStyle>);
 }
-/**
- Configuration of the finder's aspect ratio.
- */
-export declare class AspectRatio extends PartiallyConstructible {
-    /**
-     Width component of the aspect ratio.
-     @defaultValue 1.0;
-     */
-    width: number;
-    /**
-     Height component of the aspect ratio.
-     @defaultValue 1.0;
-     */
-    height: number;
-    /** @param source {@displayType `DeepPartial<AspectRatio>`} */
-    constructor(source?: DeepPartial<AspectRatio>);
-}
 /**
  Configuration of the round button.
  */
@@ -319,26 +302,6 @@ export declare class ButtonConfiguration extends PartiallyConstructible {
     /** @param source {@displayType `DeepPartial<ButtonConfiguration>`} */
     constructor(source?: DeepPartial<ButtonConfiguration>);
 }
-/**
- Configure the orientation of the interface.
-
- - `NONE`:
- Do not restrict the interface's orientation.
- - `PORTRAIT`:
- Lock the orientation to portrait.
- - `LANDSCAPE`:
- Lock the orientation to landscape.
- */
-export type OrientationLockMode = "NONE" | "PORTRAIT" | "LANDSCAPE";
-/**
- Configuration of the camera preview mode.
-
- - `FIT_IN`:
- In this mode, the camera preview frames will be scaled to the layout view size - the full preview frame content will be visible, but unused edges might appear in the preview layout.
- - `FILL_IN`:
- In this mode, the camera preview frames fill the layout view - the preview frames may contain additional content on the edges that was not visible in the preview layout.
- */
-export type CameraPreviewMode = "FIT_IN" | "FILL_IN";
 /**
  The sound selection type.
 

package/@types/ui2/configuration/FindAndPickScanningModeUseCase.d.ts

@@ -10,11 +10,11 @@ export declare class ExpectedBarcode extends PartiallyConstructible {
     /**
      Title of the barcode to find.
      */
-    title: string;
+    title: string | null;
     /**
      Image of the barcode to find.
      */
-    image: string;
+    image: string | null;
     /**
      Number of barcodes with given symbology/value required to scan.
      @defaultValue 1;

package/@types/ui2/configuration/Geometry.d.ts

@@ -0,0 +1 @@
+export * from "../../core/bridge/compiled/Geometry";

package/@types/ui2/configuration/MultipleScanningModeUseCase.d.ts

@@ -317,7 +317,7 @@ export declare class SheetContent extends PartiallyConstructible {
  Configuration of the mode for scanning multiple barcodes.
  */
 export declare class MultipleScanningMode extends PartiallyConstructible {
-    _type: "MultipleScanningMode";
+    readonly _type: "MultipleScanningMode";
     /**
      Time interval in milliseconds before a barcode is counted again. 0 = no delay. The default value is 1000.
      @defaultValue 1000;

package/@types/ui2/configuration/SingleScanningModeUseCase.d.ts

@@ -7,7 +7,7 @@ import { StyledText } from "./Common";
  Configuration of the single barcode scanning mode.
  */
 export declare class SingleScanningMode extends PartiallyConstructible {
-    _type: "SingleScanningMode";
+    readonly _type: "SingleScanningMode";
     /**
      If enabled, the confirmation sheet will be shown after the barcode has been scanned.
      @defaultValue false;

package/@types/ui2/configuration/TopBarConfiguration.d.ts

@@ -19,11 +19,6 @@ export declare class TopBarConfiguration extends PartiallyConstructible {
      @defaultValue "SOLID";
      */
     mode: TopBarMode;
-    /**
-     Visual mode used for the status bar icons.
-     @defaultValue "LIGHT";
-     */
-    statusBarMode: StatusBarMode;
     /**
      Background color of the top bar to be used when the visual mode is specified as SOLID. Otherwise ignored.
      @defaultValue "?sbColorPrimary";
@@ -47,17 +42,6 @@ export declare class TopBarConfiguration extends PartiallyConstructible {
     /** @param source {@displayType `DeepPartial<TopBarConfiguration>`} */
     constructor(source?: DeepPartial<TopBarConfiguration>);
 }
-/**
- Visual mode used for the status bar icons.
-
- - `DARK`:
- Display all icons in the status bar in black.
- - `LIGHT`:
- Display all icons in the status bar in white.
- - `HIDDEN`:
- Hide the status bar icons.
- */
-export type StatusBarMode = "DARK" | "LIGHT" | "HIDDEN";
 /**
  Visual mode used for the top bar.
 

package/@types/ui2/configuration/ViewFinderConfiguration.d.ts

@@ -1,4 +1,4 @@
-import { AspectRatio } from "./Common";
+import { AspectRatio } from "./Geometry";
 import { DeepPartial, PartiallyConstructible } from "./utils";
 /**
  Configuration of the scanning interface's viewfinder, serving as guidance to the user.
@@ -34,6 +34,9 @@ export declare class ViewFinderConfiguration extends PartiallyConstructible {
     /** @param source {@displayType `DeepPartial<ViewFinderConfiguration>`} */
     constructor(source?: DeepPartial<ViewFinderConfiguration>);
 }
+/**
+ Visual appearance of the viewfinder.
+ */
 export type FinderStyle = FinderCorneredStyle | FinderStrokedStyle;
 /** @internal */
 export declare namespace FinderStyle {
@@ -46,7 +49,7 @@ export declare namespace FinderStyle {
  Variant of the viewfinder displaying only the four corners of the scanning area as user guidance.
  */
 export declare class FinderCorneredStyle extends PartiallyConstructible {
-    _type: "FinderCorneredStyle";
+    readonly _type: "FinderCorneredStyle";
     /**
      Color of the viewfinder corner's outlines.
      @defaultValue "#FFFFFFFF";
@@ -69,7 +72,7 @@ export declare class FinderCorneredStyle extends PartiallyConstructible {
  Variant of the viewfinder displaying a full outline of the scanning area as user guidance.
  */
 export declare class FinderStrokedStyle extends PartiallyConstructible {
-    _type: "FinderStrokedStyle";
+    readonly _type: "FinderStrokedStyle";
     /**
      Color of the viewfinder's outline.
      @defaultValue "#FFFFFFFF";

package/@types/ui2/configuration.d.ts

@@ -13,8 +13,8 @@ export * from "./configuration/BarcodeRecognizerConfiguration";
 export * from "./configuration/ArTrackingOverlayConfiguration";
 export * from "./configuration/BarcodeScannerConfiguration";
 export * from "./configuration/BarcodeItem";
-export * from "./configuration/BarcodeResult";
 export * from "./configuration/MultipleScanningModeUseCase";
 export * from "./configuration/ScanbotAlertDialog";
 export * from "./configuration/CameraPermission";
 export * from "./configuration/BarcodeItemMapper";
+export * from "./configuration/BarcodeScannerTypes";

package/@types/ui2/controllers/multiple-scanning-mode-controller.d.ts

@@ -4,7 +4,8 @@ declare class Props {
     configuration: BarcodeScannerConfiguration;
     onCameraPermissionDenied: () => void;
     onSubmit: (barcodeScannerResult: BarcodeScannerResult) => void;
-    initialScanDelayHasPassed: React.MutableRefObject<boolean>;
+    onError: (error?: Error) => void;
+    scanningEnabled: React.MutableRefObject<boolean>;
 }
 export declare function MultipleScanningModeController(props: Props): React.JSX.Element;
 export {};

package/@types/ui2/controllers/single-scanning-mode-controller.d.ts

@@ -4,8 +4,9 @@ declare class Props {
     configuration: BarcodeScannerConfiguration;
     onClose: () => void;
     onSubmit: (barcodeScannerResult: BarcodeScannerResult) => void;
+    onError: (error?: Error) => void;
     onCameraPermissionDenied: () => void;
-    initialScanDelayHasPassed: React.MutableRefObject<boolean>;
+    scanningEnabled: React.MutableRefObject<boolean>;
 }
 export declare function SingleScanningModeController(props: Props): React.JSX.Element;
 export {};

package/@types/ui2/model/counted-barcodes.d.ts

@@ -1,31 +1,32 @@
-import { Barcode } from "../../model/barcode/barcode";
 import BarcodePolygon from "../../view/barcode-polygon/barocode-polygon";
 import { ArOverlayBarcodeInfo } from "../views/ar/ar-overlay-barcode-info";
+import type { CoreBarcodeItem } from "../configuration/BarcodeItem";
 export type CountedBarcode = {
-    barcode: Barcode;
+    barcode: CoreBarcodeItem;
     count: number;
     labelElement?: ArOverlayBarcodeInfo;
     polygonElement?: BarcodePolygon;
 };
+/**
+ * Function that takes the current count of a barcode and returns its new count.
+ * `oldCount` is 0 if the barcode is not yet in the list of barcodes.
+ **/
+type ComputeNewCountFunction = (oldCount: number) => number;
 export type CountedBarcodeAction = {
-    type: 'discover';
-    barcodes: Barcode[];
-} | {
-    type: 'addOne';
-    barcodes: Barcode[];
-} | {
     type: 'setCount';
-    barcode: Barcode;
-    newCount: number;
+    barcodes: CoreBarcodeItem[];
+    computeNewCount: ComputeNewCountFunction;
 } | {
     type: 'remove';
-    barcode: Barcode;
+    barcode: CoreBarcodeItem;
 } | {
     type: 'clear';
 } | {
     type: 'setHtmlElements';
-    barcode: Barcode;
+    barcode: CoreBarcodeItem;
     labelElement: ArOverlayBarcodeInfo;
     polygonElement: BarcodePolygon;
 };
+export declare const barcodesEqual: (a: CoreBarcodeItem, b: CoreBarcodeItem) => boolean;
 export declare function countedBarcodesReducer(countedBarcodes: Readonly<Readonly<CountedBarcode>[]>, action: CountedBarcodeAction): CountedBarcode[];
+export {};

package/@types/ui2/scanbot-sdk-ui.d.ts

@@ -1,7 +1,7 @@
-import { BarcodeScannerConfiguration, BarcodeScannerResult } from "./configuration";
 import * as Config from "./configuration";
+import { BarcodeScannerResult } from "./configuration/BarcodeScannerTypes";
 export default class ScanbotSDKUI {
-    static createBarcodeScanner(config: BarcodeScannerConfiguration): Promise<BarcodeScannerResult | null>;
+    static createBarcodeScanner(config: Config.BarcodeScannerConfiguration): Promise<BarcodeScannerResult | null>;
     private static createContainer;
     static readonly Config: typeof Config;
 }

package/@types/ui2/utils/barcode-mapper.d.ts

@@ -1,11 +1,15 @@
 /// <reference types="react" />
 import { BarcodeItem, BarcodeItemMapper, BarcodeMappedData } from "../configuration";
-import { Barcode } from "../../model/barcode/barcode";
+import type { CoreBarcodeItem } from "../configuration/BarcodeItem";
 export declare const BarcodeMapperContext: import("react").Context<BarcodeMapper>;
 export type BarcodeMappedDataLoadingState = {
     value: BarcodeMappedData | null;
     state: 'LOADED' | 'LOADING' | 'RETRY_DIALOG_OPEN' | 'FAILED';
 };
+type OnEvictionListener = {
+    barcode: CoreBarcodeItem;
+    callback: () => void;
+};
 export declare class BarcodeMapper {
     private barcodeItemMapper;
     private onError;
@@ -18,12 +22,20 @@ export declare class BarcodeMapper {
      * If the retry function is called, all cached entries that are currently in this "RETRY_DIALOG_OPEN" state are cleared.
      */
     constructor(barcodeItemMapper: BarcodeItemMapper, onError: (retry: () => void, cancel: () => void) => void);
-    mapBarcodeToBarcodeItem(barcode: Barcode, count: number): BarcodeItem;
+    mapBarcodeToBarcodeItem(barcode: CoreBarcodeItem, count: number): Promise<BarcodeItem>;
     /**
      * Results are cached.
      * Note that, because resulting promise will be used in useMemo, it is important we return the identical
      * promise for the same input (not just a promise with the same value).
+     * Also note that we must not make this function async:
+     *   If we do this, the function will only be evaluated once somebody awaits its result.
+     *   It might be, that before that happens, the function is called again. In this case, the cache value will not
+     *   have been set yet.
      * */
     private getBarcodeMappedData;
-    useBarcodeMappedData(barcode: Barcode): BarcodeMappedDataLoadingState | null;
+    useBarcodeMappedData(barcode: CoreBarcodeItem): BarcodeMappedDataLoadingState | null;
+    private onEvictionListeners;
+    addOnEvictionListener(listener: OnEvictionListener): void;
+    removeOnEvictionListener(listener: OnEvictionListener): void;
 }
+export {};

package/@types/ui2/utils/camera-config.d.ts

@@ -1,3 +1,3 @@
-import { CameraConfiguration } from "../configuration/CameraConfiguration";
 import { BarcodeScannerConfiguration as BarcodeScannerViewConfig } from "../../model/configuration/barcode-scanner-configuration";
-export declare function barcodeScannerViewConfigFromRtuUiConfig(config: CameraConfiguration): Partial<BarcodeScannerViewConfig>;
+import { BarcodeScannerConfiguration } from "../configuration/BarcodeScannerConfiguration";
+export declare function barcodeScannerViewConfigFromRtuUiConfig(config: BarcodeScannerConfiguration): Partial<BarcodeScannerViewConfig>;

package/@types/ui2/utils/styled-input.d.ts

@@ -2,5 +2,5 @@ import React from "react";
 interface Props extends React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement> {
     inputRef: React.RefObject<HTMLInputElement>;
 }
-export declare function StyledInput(props: Props): React.JSX.Element;
+export declare function StyledInput({ inputRef, ...props }: Props): React.JSX.Element;
 export {};

package/@types/ui2/views/action-button/action-button-container.d.ts

@@ -1,6 +1,7 @@
 import React from "react";
 import BarcodeScannerView from "../../../barcode-scanner-view";
 import { ActionBarConfiguration } from "../../configuration/ActionBarConfiguration";
+import { CameraModule } from "../../configuration/CameraConfiguration";
 export type Facingmode = "environment" | "user";
 export declare class Props {
     capabilities?: ActionButtonCapabilities;
@@ -9,6 +10,7 @@ export declare class Props {
     bottomPadding: number;
     config: ActionBarConfiguration;
     torchEnabledInitially: boolean;
+    initialCameraModule: CameraModule;
     zoomSteps: number[];
     defaultZoomFactor: number;
 }

package/@types/ui2/views/barcode-scanner.d.ts

@@ -1,5 +1,4 @@
 import React from "react";
-import { Barcode } from "../../model/barcode/barcode";
 import { ArOverlayGeneralConfiguration } from "../configuration/ArTrackingOverlayConfiguration";
 import { ActionBarConfiguration } from "../configuration/ActionBarConfiguration";
 import { BarcodeScannerConfiguration as BarcodeScannerViewConfig } from "../../model/configuration/barcode-scanner-configuration";
@@ -7,18 +6,20 @@ import { ViewFinderPadding } from "../../view/view-finder";
 import BarcodePolygon from "../../view/barcode-polygon/barocode-polygon";
 import BarcodePolygonLabel from "../../view/barcode-polygon/barcode-polygon-label";
 import { CameraConfiguration } from "../configuration/CameraConfiguration";
+import type { CoreBarcodeItem } from "../configuration/BarcodeItem";
 export declare class Props {
     cameraConfiguration: CameraConfiguration;
     arOverlay: ArOverlayGeneralConfiguration;
     actionBarConfig: ActionBarConfiguration;
     actionBarBottomPadding: number;
-    arOnBarcodeEnter: (code: Barcode, polygon: BarcodePolygon, label: BarcodePolygonLabel) => void;
-    arOnBarcodeClick: (barcode: Barcode) => void;
+    arOnBarcodeEnter: (code: CoreBarcodeItem, polygon: BarcodePolygon, label: BarcodePolygonLabel) => void;
+    arOnBarcodeClick: (barcode: CoreBarcodeItem) => void;
     scanningPaused: boolean;
     barcodeScannerViewConfig: BarcodeScannerViewConfig;
     viewFinderPadding: ViewFinderPadding;
     containerId: string;
     onCameraPermissionDenied: () => void;
     setActionButtonsVisible: (visible: boolean) => void;
+    onLicenseError?: () => void;
 }
 export declare function BarcodeScanner(props: Props): React.JSX.Element;

package/@types/ui2/views/drawer/subviews/barcode-list-item.d.ts

@@ -1,10 +1,10 @@
 import React from "react";
-import { Barcode } from "../../../../model/barcode/barcode";
 import { BarcodeInfoPropsBase } from "../../barcode-info/barcode-info";
 import { SwipeToDelete } from "../../../configuration";
+import { BarcodeScannerTypes } from "../../../../core-types";
 export interface Props extends BarcodeInfoPropsBase {
-    barcode: Barcode;
-    onDelete: (barcode: Barcode) => void;
+    barcode: BarcodeScannerTypes.BarcodeItem;
+    onDelete: (barcode: BarcodeScannerTypes.BarcodeItem) => void;
     readonlyCount: number | null;
     swipeToDeleteConfig: SwipeToDelete;
     sheetColor: string;

package/@types/ui2/views/form/dialog-button.d.ts

@@ -1,9 +1,9 @@
 import React from "react";
 import { ButtonConfiguration } from "../../configuration";
-import * as Muicon from "@mui/icons-material";
 import { ButtonProps } from "@mui/material/Button/Button";
+import { SvgIconComponent } from "@mui/icons-material";
 declare class Props extends ButtonConfiguration {
-    icon?: keyof typeof Muicon;
+    icon?: SvgIconComponent;
     onClick: () => void;
     style: React.CSSProperties;
     type?: ButtonProps['type'];

package/@types/utils/dto/MagneticLine.d.ts

@@ -1,6 +1,6 @@
-import { Point } from "./Point";
+import { Point } from "../../core-types";
 export declare class MagneticLine {
-    p1: Point;
-    p2: Point;
-    constructor(p1: Point, p2: Point);
+    start: Point;
+    end: Point;
+    constructor(start: Point, end: Point);
 }

package/@types/utils/dto/Point.d.ts

@@ -6,8 +6,8 @@ export declare class Point {
     constructor(x: number, y: number);
     static toPolygon(points: Point[], size: Size): Polygon;
     static scaleToPoint(pt: Point, x: number, y: number, scale: number): Point;
-    static scaleListToHtmlElement(points: Point[], original: ImageData, html: HTMLElement): Point[];
-    static scaleToHtmlElement(point: Point, original: ImageData, html: HTMLElement): Point;
+    static scaleListToHtmlElement(points: Point[], original: Size, html: HTMLElement): Point[];
+    static scaleToHtmlElement(point: Point, original: Size, html: HTMLElement): Point;
     static scaleUpTo(pt: Point, size: Size): Point;
     static scaleDownTo(pt: Point, size: Size): Point;
     static fromHtmlElement(element: HTMLElement): Point;

package/@types/utils/image-utils.d.ts

@@ -10,4 +10,5 @@ export declare class ImageUtils {
     static saveBlob(blob: Blob, name: string): void;
     static convertImageDataWrapperToImageData(imageDataWrapper: ImageDataWrapper): ImageData;
     static wrapperToBase64(wrapper: ImageDataWrapper): string;
+    static toBase64(data: Uint8Array): Promise<string>;
 }

package/@types/utils/react/usePromise.d.ts

@@ -1,7 +1,9 @@
 type LoadingState<T> = {
     loading: boolean;
     value: T | undefined;
-    error: any | null;
+    error: {
+        reason: any;
+    } | null;
 };
 /**
  * Returns null if no promise is given.

package/@types/utils/utils.d.ts

@@ -2,6 +2,6 @@ export declare class Utils {
     static toPixelSize(size: number): string;
     static containsString(content: string, substring: string): boolean;
     static copy(item: any): any;
-    static getProperty(obj: any, propertyName: string): string;
+    static getProperty<T>(obj: T, propertyName: keyof T): T[keyof T] | undefined;
     static uuid(): string;
 }

package/@types/utils/video-stream.d.ts

@@ -29,5 +29,6 @@ export default class VideoStream extends React.Component<VideoStreamProps, Video
     render(): React.ReactNode;
     updateTorch(enabled: boolean): Promise<void>;
     getCapabilities(): MediaTrackCapabilities | undefined;
+    static getMediaTrackCapabilities(track: MediaStreamTrack): MediaTrackCapabilities | undefined;
     getVideoTrack(): MediaStreamTrack | undefined;
 }

package/@types/view/action-bar/bottom-action-bar.d.ts

@@ -1,8 +1,8 @@
 import React from "react";
-import { Barcode } from "../../model/barcode/barcode";
+import type { BarcodeScannerTypes } from "../../core-types";
 export default class BottomActionBar extends React.Component<any, any> {
     constructor(props: any);
-    update(barcodes: Barcode[]): void;
+    update(barcodes: BarcodeScannerTypes.BarcodeItem[]): void;
     didScan(): boolean;
     render(): React.ReactNode;
 }

package/@types/view/barcode-calculation/barcode-calculation-popup-list.d.ts

@@ -1,8 +1,8 @@
 import React from "react";
-import { Barcode } from "../../model/barcode/barcode";
+import { BarcodeScannerTypes } from "../../core-types";
 export default class BarcodeCalculationPopupList extends React.Component<any, any> {
     constructor(props: any);
-    toUniqueListWithDuplicateCounter(barcodes: Barcode[]): Barcode[];
+    toUniqueListWithDuplicateCounter(barcodes: BarcodeScannerTypes.BarcodeItem[]): BarcodeScannerTypes.BarcodeItem[];
     update(barcodes: any): void;
     render(): React.ReactNode;
 }

package/@types/view/barcode-calculation/barcode-calculation-popup.d.ts

@@ -1,6 +1,6 @@
 import React, { CSSProperties } from "react";
-import { Barcode } from "../../model/barcode/barcode";
 import BarcodeCalculationPopupList from "./barcode-calculation-popup-list";
+import type { BarcodeScannerTypes } from "../../core-types";
 export declare enum AnimationType {
     None = 0,
     PushRight = 1,
@@ -10,15 +10,15 @@ export declare enum AnimationType {
 export default class BarcodeCalculationPopup extends React.Component<any, any> {
     list: BarcodeCalculationPopupList;
     previousDestination?: string;
-    barcodes?: Barcode[];
+    barcodes?: BarcodeScannerTypes.BarcodeItem[];
     constructor(props: any);
     containerStyle(transform: string): CSSProperties;
     render(): React.ReactNode;
     reset(): void;
     private _isVisible;
     isVisible(): boolean;
-    push(type: AnimationType, barcodes: Barcode[]): void;
-    update(barcodes: Barcode[]): void;
+    push(type: AnimationType, barcodes: BarcodeScannerTypes.BarcodeItem[]): void;
+    update(barcodes: BarcodeScannerTypes.BarcodeItem[]): void;
     pop(): void;
     onAnimationStart(): void;
     onAnimationEnd(): void;

package/@types/view/barcode-calculation/scanned-image-with-overlay.d.ts

@@ -1,9 +1,9 @@
 import React, { ReactNode } from "react";
-import { BarcodeResult } from "../../model/barcode/barcode-result";
+import { BarcodeScannerResultWithSize } from "../../model/barcode/barcode-result";
 export default class ScannedImageWithOverlay extends React.Component<any, any> {
     image: HTMLImageElement | undefined;
     constructor(props: any);
-    update(result: BarcodeResult): void;
+    update(result: BarcodeScannerResultWithSize): void;
     reset(): void;
     render(): ReactNode;
 }

package/@types/view/barcode-polygon/animated-barcode-selection-overlay.d.ts

@@ -1,12 +1,13 @@
 import React from "react";
 import ScanbotCameraView from "../scanbot-camera-view";
-import { Barcode } from "../../model/barcode/barcode";
 import { BarcodeOverlay } from "./barcode-overlay";
 import BarcodePolygon from "./barocode-polygon";
 import BarcodePolygonLabel from "./barcode-polygon-label";
 import { SelectionOverlayConfiguration } from "../../model/configuration/selection-overlay-configuration";
 import { ArOverlayBarcodeInfo, AROverlayBarcodeInfoConfig } from "../../ui2/views/ar/ar-overlay-barcode-info";
 import { Frame } from "../../utils/dto/Frame";
+import { Size } from "../../utils/dto/Size";
+import { BarcodeScannerTypes } from "../../core-types";
 export declare class BarcodePolygonElement {
     element: BarcodeOverlay;
     updatedAt?: number;
@@ -18,15 +19,15 @@ export declare class BarcodePolygonElement {
 export declare class SelectionOverlayProps {
     style?: React.CSSProperties;
     configuration?: SelectionOverlayConfiguration;
-    onPolygonSelected?: (code: Barcode) => void;
-    onPolygonClick?: (code: Barcode) => void;
-    onBarcodeFound?: (code: Barcode, polygon: BarcodePolygon, label: BarcodePolygonLabel) => void;
+    onPolygonSelected?: (code: BarcodeScannerTypes.BarcodeItem) => void;
+    onPolygonClick?: (code: BarcodeScannerTypes.BarcodeItem) => void;
+    onBarcodeFound?: (code: BarcodeScannerTypes.BarcodeItem, polygon: BarcodePolygon, label: BarcodePolygonLabel) => void;
     LabelComponent: (typeof BarcodePolygonLabel | typeof ArOverlayBarcodeInfo);
     labelComponentConfig: {} | AROverlayBarcodeInfoConfig;
 }
 export default class AnimatedBarcodeSelectionOverlay extends React.Component<SelectionOverlayProps, any> {
     constructor(props: SelectionOverlayProps);
-    update(finderRect: Frame, camera: ScanbotCameraView, imageData: ImageData, container: any, codes: Barcode[]): void;
+    update(finderRect: Frame, camera: ScanbotCameraView, originalImageSize: Size, codes: BarcodeScannerTypes.BarcodeItem[]): void;
     onPolygonClick(model: BarcodeOverlay): void;
     render(): React.ReactNode;
 }

package/@types/view/barcode-polygon/barcode-overlay.d.ts

@@ -1,9 +1,9 @@
-import { Barcode } from "../../model/barcode/barcode";
 import { Point } from "../../utils/dto/Point";
+import { BarcodeScannerTypes } from "../../core-types";
 export declare class BarcodeOverlay {
     base64Image?: string;
-    code: Barcode;
+    code: BarcodeScannerTypes.BarcodeItem;
     points: Point[];
     highlighted: boolean;
-    constructor(barcode: Barcode);
+    constructor(barcode: BarcodeScannerTypes.BarcodeItem);
 }

package/@types/view/barcode-polygon/barcode-polygon-label.d.ts

@@ -2,7 +2,7 @@ import React from "react";
 import { BarcodeOverlay } from "./barcode-overlay";
 import { Point } from "../../utils/dto/Point";
 import { BarcodePolygonLabelStyle, SelectionOverlayConfiguration, SelectionOverlayTextFormat } from "../../model/configuration/selection-overlay-configuration";
-import { Barcode } from "../../model/barcode/barcode";
+import { BarcodeScannerTypes } from "../../core-types";
 export declare class BarcodePolygonLabelProps {
     element: BarcodeOverlay;
     configuration: SelectionOverlayConfiguration;
@@ -18,7 +18,7 @@ export default class BarcodePolygonLabel<Props extends BarcodePolygonLabelProps
     style(style: BarcodePolygonLabelStyle): void;
     update(model: BarcodeOverlay): void;
     label: HTMLDivElement;
-    formatText(code: Barcode, format: SelectionOverlayTextFormat): string | undefined;
+    formatText(code: BarcodeScannerTypes.BarcodeItem, format: SelectionOverlayTextFormat): string | undefined;
     render(): React.ReactNode;
 }
 export {};

package/@types/view/cropping/draggable-base-container.d.ts

@@ -19,8 +19,14 @@ interface DraggableBaseContainerProps {
     scale: number;
     rotations: number;
     points: Point[];
-    cornerMoveStart?: any;
-    cornerMoved?: any;
+    cornerMoveStart?: (data: {
+        index: number;
+        point: Point;
+    }) => void;
+    cornerMoved?: (data: {
+        index: number;
+        point: Point;
+    }) => void;
     cornerMoveEnd?: any;
     lineMoved?: (movingLine: MovingLine) => void;
 }