scandit-datacapture-frameworks-core 6.21.0-beta.2

package/dist/dts/context/ContextStatus.d.ts

@@ -0,0 +1,17 @@
+export interface ContextStatusJSON {
+    code: number;
+    isValid: boolean;
+    message: string;
+}
+export interface PrivateContextStatus {
+    fromJSON(json: ContextStatusJSON): ContextStatus;
+}
+export declare class ContextStatus {
+    private _message;
+    private _code;
+    private _isValid;
+    private static fromJSON;
+    get message(): string;
+    get code(): number;
+    get isValid(): boolean;
+}

package/dist/dts/context/DataCaptureComponent.d.ts

@@ -0,0 +1,7 @@
+import { DataCaptureContext } from "./DataCaptureContext";
+export interface DataCaptureComponent {
+    readonly id: string;
+}
+export interface PrivateDataCaptureComponent {
+    _context: DataCaptureContext;
+}

package/dist/dts/context/DataCaptureContext.d.ts

@@ -0,0 +1,50 @@
+import { BaseDataCaptureView } from "../view";
+import { FrameSource } from "../frame";
+import { DefaultSerializeable } from "../serializable";
+import { DataCaptureComponent } from "./DataCaptureComponent";
+import { DataCaptureContextController } from "./DataCaptureContextController";
+import { DataCaptureContextCreationOptions } from "./DataCaptureContextCreationOptions";
+import { DataCaptureContextListener } from "./DataCaptureContextListener";
+import { DataCaptureContextSettings } from "./DataCaptureContextSettings";
+import { DataCaptureMode } from "./DataCaptureMode";
+export declare class DataCaptureContext extends DefaultSerializeable {
+    private licenseKey;
+    private deviceName;
+    private framework;
+    private frameworkVersion;
+    private settings;
+    private _frameSource;
+    private view;
+    private modes;
+    private components;
+    private controller;
+    private listeners;
+    private static get coreDefaults();
+    get frameSource(): FrameSource | null;
+    static get deviceID(): string | null;
+    static forLicenseKey(licenseKey: string): DataCaptureContext;
+    static forLicenseKeyWithSettings(licenseKey: string, settings: DataCaptureContextSettings | null): DataCaptureContext;
+    static forLicenseKeyWithOptions(licenseKey: string, options: DataCaptureContextCreationOptions | null): DataCaptureContext;
+    private constructor();
+    setFrameSource(frameSource: FrameSource | null): Promise<void>;
+    addListener(listener: DataCaptureContextListener): void;
+    removeListener(listener: DataCaptureContextListener): void;
+    addMode(mode: DataCaptureMode): void;
+    removeMode(mode: DataCaptureMode): void;
+    removeAllModes(): void;
+    dispose(): void;
+    applySettings(settings: DataCaptureContextSettings): Promise<void>;
+    private initialize;
+    private update;
+    private addComponent;
+}
+export interface PrivateDataCaptureContext {
+    controller: DataCaptureContextController;
+    modes: [DataCaptureMode];
+    components: [DataCaptureComponent];
+    listeners: DataCaptureContextListener[];
+    view: BaseDataCaptureView;
+    update: () => Promise<void>;
+    initialize(): void;
+    addComponent: (component: DataCaptureComponent) => Promise<void>;
+}

package/dist/dts/context/DataCaptureContextController.d.ts

@@ -0,0 +1,30 @@
+import { DataCaptureContext } from "./DataCaptureContext";
+export interface DataCaptureContextProxy {
+    contextFromJSON(context: DataCaptureContext): Promise<void>;
+    updateContextFromJSON(context: DataCaptureContext): Promise<void>;
+    dispose(): void;
+    registerListenerForEvents(): void;
+    unsubscribeListener(): void;
+    subscribeDidChangeStatus(): void;
+    subscribeDidStartObservingContext(): void;
+}
+export declare enum DataCaptureContextEvents {
+    didChangeStatus = "didChangeStatus",
+    didStartObservingContext = "didStartObservingContext"
+}
+export declare class DataCaptureContextController {
+    private _proxy;
+    private context;
+    private eventEmitter;
+    private get privateContext();
+    static forDataCaptureContext(context: DataCaptureContext): DataCaptureContextController;
+    private constructor();
+    updateContextFromJSON(): Promise<void>;
+    dispose(): void;
+    private unsubscribeListener;
+    private initialize;
+    private initializeContextFromJSON;
+    private subscribeListener;
+    private notifyListenersOfDeserializationError;
+    private notifyListenersOfDidChangeStatus;
+}

package/dist/dts/context/DataCaptureContextCreationOptions.d.ts

@@ -0,0 +1,3 @@
+export interface DataCaptureContextCreationOptions {
+    deviceName?: string | null;
+}

package/dist/dts/context/DataCaptureContextListener.d.ts

@@ -0,0 +1,6 @@
+import { ContextStatus } from "./ContextStatus";
+import { DataCaptureContext } from "./DataCaptureContext";
+export interface DataCaptureContextListener {
+    didChangeStatus?(context: DataCaptureContext, contextStatus: ContextStatus): void;
+    didStartObservingContext?(context: DataCaptureContext): void;
+}

package/dist/dts/context/DataCaptureContextSettings.d.ts

@@ -0,0 +1,6 @@
+import { DefaultSerializeable } from "../serializable";
+export declare class DataCaptureContextSettings extends DefaultSerializeable {
+    constructor();
+    setProperty(name: string, value: any): void;
+    getProperty(name: string): any;
+}

package/dist/dts/context/DataCaptureMode.d.ts

@@ -0,0 +1,9 @@
+import { Serializeable } from "../serializable";
+import { DataCaptureContext } from "./DataCaptureContext";
+export interface DataCaptureMode extends Serializeable {
+    isEnabled: boolean;
+    readonly context: DataCaptureContext | null;
+}
+export interface PrivateDataCaptureMode {
+    _context: DataCaptureContext | null;
+}

package/dist/dts/context/index.d.ts

@@ -0,0 +1,11 @@
+export { ContextStatus } from "./ContextStatus";
+export { DataCaptureComponent, PrivateDataCaptureComponent } from "./DataCaptureComponent";
+export { DataCaptureContextCreationOptions } from "./DataCaptureContextCreationOptions";
+export { DataCaptureContextSettings } from "./DataCaptureContextSettings";
+export { DataCaptureContext } from "./DataCaptureContext";
+export { DataCaptureContextProxy, DataCaptureContextEvents } from "./DataCaptureContextController";
+export { DataCaptureMode } from "./DataCaptureMode";
+export { DataCaptureContextListener } from "./DataCaptureContextListener";
+export { PrivateContextStatus } from "./ContextStatus";
+export { PrivateDataCaptureContext } from "./DataCaptureContext";
+export { PrivateDataCaptureMode } from "./DataCaptureMode";

package/dist/dts/defaults/CoreDefaults.d.ts

@@ -0,0 +1,73 @@
+import { CameraPosition, FocusGesture, FocusGestureStrategy, FocusRange, LogoStyle, VideoResolution, ZoomGesture } from "../camera";
+import { Anchor, Color, MarginsWithUnit, NumberWithUnit, PointWithUnit, SizeWithUnitAndAspect } from "../common";
+import { LaserlineViewfinderStyle, RectangularViewfinderAnimation, RectangularViewfinderLineStyle, RectangularViewfinderStyle } from "../viewfinder";
+export interface CameraSettingsDefaults {
+    preferredResolution: VideoResolution;
+    zoomFactor: number;
+    focusRange: FocusRange;
+    zoomGestureZoomFactor: number;
+    focusGestureStrategy: FocusGestureStrategy;
+    shouldPreferSmoothAutoFocus: boolean;
+    properties: {
+        [key: string]: any;
+    };
+}
+export interface CoreDefaults {
+    Camera: {
+        Settings: CameraSettingsDefaults;
+        defaultPosition: CameraPosition | null;
+        availablePositions: CameraPosition[];
+    };
+    DataCaptureView: {
+        scanAreaMargins: MarginsWithUnit;
+        pointOfInterest: PointWithUnit;
+        logoAnchor: Anchor;
+        logoOffset: PointWithUnit;
+        focusGesture: FocusGesture | null;
+        zoomGesture: ZoomGesture | null;
+        logoStyle: LogoStyle;
+    };
+    LaserlineViewfinder: {
+        defaultStyle: string;
+        styles: {
+            [key: string]: {
+                style: LaserlineViewfinderStyle;
+                width: NumberWithUnit;
+                enabledColor: Color;
+                disabledColor: Color;
+            };
+        };
+    };
+    RectangularViewfinder: {
+        defaultStyle: string;
+        styles: {
+            [key: string]: {
+                size: SizeWithUnitAndAspect;
+                color: Color;
+                style: RectangularViewfinderStyle;
+                lineStyle: RectangularViewfinderLineStyle;
+                dimming: string;
+                disabledDimming: string;
+                animation: RectangularViewfinderAnimation | null;
+                disabledColor: Color;
+            };
+        };
+    };
+    SpotlightViewfinder?: {
+        size: SizeWithUnitAndAspect;
+        enabledBorderColor: Color;
+        disabledBorderColor: Color;
+        backgroundColor: Color;
+    };
+    AimerViewfinder: {
+        frameColor: Color;
+        dotColor: Color;
+    };
+    Brush: {
+        fillColor: Color;
+        strokeColor: Color;
+        strokeWidth: number;
+    };
+    deviceID: string | null;
+}
+export declare function parseDefaults(jsonDefaults: any): CoreDefaults;

package/dist/dts/defaults/getCoreDefaults.d.ts

@@ -0,0 +1,2 @@
+import { CoreDefaults } from "./CoreDefaults";
+export declare function getCoreDefaults(): CoreDefaults;

package/dist/dts/defaults/index.d.ts

@@ -0,0 +1,2 @@
+export { CoreDefaults } from "./CoreDefaults";
+export { getCoreDefaults } from "./getCoreDefaults";

package/dist/dts/defaults/loadCoreDefaults.d.ts

@@ -0,0 +1 @@
+export declare function loadCoreDefaults(jsonDefaults: any): void;

package/dist/dts/feedback/Feedback.d.ts

@@ -0,0 +1,22 @@
+import { DefaultSerializeable } from "../serializable";
+import { Sound, SoundJSON } from "./Sound";
+import { Vibration, VibrationJSON } from "./Vibration";
+export interface FeedbackJSON {
+    vibration: VibrationJSON | null;
+    sound: SoundJSON | null;
+}
+export interface PrivateFeedback {
+    fromJSON(json: FeedbackJSON): Feedback;
+}
+export declare class Feedback extends DefaultSerializeable {
+    static get defaultFeedback(): Feedback;
+    private _vibration;
+    private _sound;
+    private controller;
+    get vibration(): Vibration | null;
+    get sound(): Sound | null;
+    private static fromJSON;
+    constructor(vibration: Vibration | null, sound: Sound | null);
+    emit(): void;
+    toJSON(): object;
+}

package/dist/dts/feedback/FeedbackController.d.ts

@@ -0,0 +1,11 @@
+import { Feedback } from "./Feedback";
+export interface FeedbackProxy {
+    emitFeedback(feedback: Feedback): Promise<void>;
+}
+export declare class FeedbackController {
+    private feedback;
+    private _proxy;
+    private constructor();
+    static forFeedback(feedback: Feedback): FeedbackController;
+    emit(): void;
+}

package/dist/dts/feedback/Sound.d.ts

@@ -0,0 +1,13 @@
+import { DefaultSerializeable } from "../serializable";
+export interface SoundJSON {
+    resource: string | null;
+}
+export interface PrivateSound {
+    fromJSON(json: SoundJSON): Sound;
+}
+export declare class Sound extends DefaultSerializeable {
+    resource: string | null;
+    static get defaultSound(): Sound;
+    private static fromJSON;
+    constructor(resource: string | null);
+}

package/dist/dts/feedback/Vibration.d.ts

@@ -0,0 +1,30 @@
+import { DefaultSerializeable } from "../serializable";
+export interface VibrationJSON {
+    type: string;
+    timings: number[] | null;
+    amplitudes: number[] | null;
+}
+export interface PrivateVibration {
+    fromJSON(json: VibrationJSON): Vibration;
+}
+export declare class Vibration extends DefaultSerializeable {
+    private type;
+    static get defaultVibration(): Vibration;
+    static get selectionHapticFeedback(): Vibration;
+    static get successHapticFeedback(): Vibration;
+    private static fromJSON;
+    protected constructor(type: VibrationType);
+}
+export declare enum VibrationType {
+    default = "default",
+    selectionHaptic = "selectionHaptic",
+    successHaptic = "successHaptic",
+    waveForm = "waveForm"
+}
+export declare class WaveFormVibration extends Vibration {
+    private _timings;
+    get timings(): number[];
+    private _amplitudes;
+    get amplitudes(): number[] | null;
+    constructor(timings: number[], amplitudes?: number[] | null);
+}

package/dist/dts/feedback/index.d.ts

@@ -0,0 +1,7 @@
+export { Vibration, WaveFormVibration } from "./Vibration";
+export { Sound } from "./Sound";
+export { Feedback } from "./Feedback";
+export { FeedbackProxy } from "./FeedbackController";
+export { VibrationJSON, PrivateVibration } from "./Vibration";
+export { SoundJSON, PrivateSound } from "./Sound";
+export { FeedbackJSON, PrivateFeedback } from "./Feedback";

package/dist/dts/frame/FrameData.d.ts

@@ -0,0 +1,16 @@
+import { ImageBuffer, ImageBufferJSON } from "./ImageBuffer";
+export interface FrameData {
+    readonly imageBuffers: ImageBuffer[];
+    readonly orientation: number;
+}
+export interface FrameDataJSON {
+    imageBuffers: ImageBufferJSON[];
+    orientation: number;
+}
+export declare class PrivateFrameData implements FrameData {
+    private _imageBuffers;
+    private _orientation;
+    get imageBuffers(): ImageBuffer[];
+    get orientation(): number;
+    static fromJSON(json: FrameDataJSON): FrameData;
+}

package/dist/dts/frame/FrameSource.d.ts

@@ -0,0 +1,14 @@
+import { Serializeable } from "../serializable";
+import { FrameSourceState } from "./FrameSourceState";
+import { FrameSourceListener } from "./FrameSourceListener";
+import { DataCaptureContext } from "../context/DataCaptureContext";
+export interface PrivateFrameSource {
+    context: DataCaptureContext | null;
+}
+export interface FrameSource extends Serializeable {
+    readonly desiredState: FrameSourceState;
+    switchToDesiredState(desiredState: FrameSourceState): Promise<void>;
+    getCurrentState(): Promise<FrameSourceState>;
+    addListener(listener: FrameSourceListener): void;
+    removeListener(listener: FrameSourceListener): void;
+}

package/dist/dts/frame/FrameSourceListener.d.ts

@@ -0,0 +1,5 @@
+import { FrameSourceState } from "./FrameSourceState";
+import { FrameSource } from "./FrameSource";
+export interface FrameSourceListener {
+    didChangeState?(frameSource: FrameSource, newState: FrameSourceState): void;
+}

package/dist/dts/frame/FrameSourceState.d.ts

@@ -0,0 +1,11 @@
+export declare enum FrameSourceState {
+    On = "on",
+    Off = "off",
+    Starting = "starting",
+    Stopping = "stopping",
+    Standby = "standby",
+    BootingUp = "bootingUp",
+    WakingUp = "wakingUp",
+    GoingToSleep = "goingToSleep",
+    ShuttingDown = "shuttingDown"
+}

package/dist/dts/frame/ImageBuffer.d.ts

@@ -0,0 +1,18 @@
+export declare class ImageBuffer {
+    private _width;
+    private _height;
+    private _data;
+    get width(): number;
+    get height(): number;
+    get data(): string;
+}
+export interface PrivateImageBuffer {
+    _width: number;
+    _height: number;
+    _data: string;
+}
+export interface ImageBufferJSON {
+    width: number;
+    height: number;
+    data: string;
+}

package/dist/dts/frame/ImageFrameSource.d.ts

@@ -0,0 +1,41 @@
+import { DefaultSerializeable } from "../serializable";
+import { CameraPosition } from "../camera";
+import { DataCaptureContext } from "../context";
+import { FrameSourceListener } from "./FrameSourceListener";
+import { FrameSourceState } from "./FrameSourceState";
+import { FrameSource } from "./FrameSource";
+import { ImageFrameSourceController } from "./ImageFrameSourceController";
+export interface ImageFrameSourceJSON {
+    image: string;
+}
+export interface PrivateImageFrameSource {
+    context: DataCaptureContext | null;
+    _desiredState: FrameSourceState;
+    listeners: FrameSourceListener[];
+    _controller: ImageFrameSourceController;
+    controller: ImageFrameSourceController;
+    position: CameraPosition;
+    initialize: () => void;
+    didChange: () => Promise<void>;
+}
+export declare class ImageFrameSource extends DefaultSerializeable implements FrameSource {
+    private set context(value);
+    private get context();
+    get desiredState(): FrameSourceState;
+    private position;
+    private type;
+    private image;
+    private _id;
+    private _desiredState;
+    private listeners;
+    private _context;
+    private controller;
+    static create(image: string): ImageFrameSource;
+    private static fromJSON;
+    private constructor();
+    private didChange;
+    switchToDesiredState(state: FrameSourceState): Promise<void>;
+    addListener(listener: FrameSourceListener | null): void;
+    removeListener(listener: FrameSourceListener | null): void;
+    getCurrentState(): Promise<FrameSourceState>;
+}

package/dist/dts/frame/ImageFrameSourceController.d.ts

@@ -0,0 +1,19 @@
+import { FrameSourceState } from "./FrameSourceState";
+import { ImageFrameSource } from "./ImageFrameSource";
+import { CameraPosition } from "../camera";
+export interface ImageFrameSourceProxy {
+    getCurrentCameraState(position: CameraPosition): Promise<FrameSourceState>;
+    registerListenerForEvents(): void;
+    unregisterListenerForEvents(): void;
+    subscribeDidChangeState(): void;
+}
+export declare class ImageFrameSourceController {
+    private imageFrameSource;
+    private eventEmitter;
+    private _proxy;
+    static forImage(imageFrameSource: ImageFrameSource): ImageFrameSourceController;
+    private constructor();
+    getCurrentState(): Promise<FrameSourceState>;
+    subscribeListener(): void;
+    unsubscribeListener(): void;
+}

package/dist/dts/frame/index.d.ts

@@ -0,0 +1,9 @@
+export { FrameSource } from "./FrameSource";
+export { FrameSourceListener } from "./FrameSourceListener";
+export { FrameSourceState } from "./FrameSourceState";
+export { FrameData } from "./FrameData";
+export { ImageBuffer } from "./ImageBuffer";
+export { ImageFrameSource } from "./ImageFrameSource";
+export { ImageFrameSourceProxy } from "./ImageFrameSourceController";
+export { PrivateImageBuffer, ImageBufferJSON } from "./ImageBuffer";
+export { PrivateFrameData, FrameDataJSON } from "./FrameData";

package/dist/dts/index.d.ts

@@ -0,0 +1,16 @@
+export { EventEmitter } from "./EventEmitter";
+export { BaseController, BaseNativeProxy } from "./BaseController";
+export * from "./defaults";
+export { loadCoreDefaults } from "./defaults/loadCoreDefaults";
+export * from "./common";
+export * from "./context";
+export * from "./serializable";
+export * from "./feedback";
+export * from "./camera";
+export * from "./frame";
+export * from "./viewfinder";
+export * from "./locationselection";
+export * from "./view";
+export * from "./LicenseInfo";
+export * from "./Expiration";
+export { FactoryMaker } from "./FactoryMaker";

package/dist/dts/locationselection/LocationSelection.d.ts

@@ -0,0 +1,2 @@
+export interface LocationSelection {
+}

package/dist/dts/locationselection/NoneLocationSelection.d.ts

@@ -0,0 +1,3 @@
+export declare const NoneLocationSelection: {
+    type: string;
+};

package/dist/dts/locationselection/RadiusLocationSelection.d.ts

@@ -0,0 +1,16 @@
+import { DefaultSerializeable } from "../serializable";
+import { LocationSelection } from "./LocationSelection";
+import { NumberWithUnit, NumberWithUnitJSON } from "../common";
+export interface RadiusLocationSelectionJSON {
+    radius: NumberWithUnitJSON;
+}
+export interface PrivateRadiusLocationSelection {
+    fromJSON(JSON: RadiusLocationSelectionJSON): RadiusLocationSelection;
+}
+export declare class RadiusLocationSelection extends DefaultSerializeable implements LocationSelection {
+    private type;
+    private _radius;
+    get radius(): NumberWithUnit;
+    static fromJSON(JSON: RadiusLocationSelectionJSON): RadiusLocationSelection;
+    constructor(radius: NumberWithUnit);
+}

package/dist/dts/locationselection/RectangularLocationSelection.d.ts

@@ -0,0 +1,18 @@
+import { DefaultSerializeable } from "../serializable";
+import { LocationSelection } from "./LocationSelection";
+import { NumberWithUnit, SizeWithUnit, SizeWithUnitAndAspect, SizeWithUnitAndAspectJSON } from "../common";
+export interface RectangularLocationSelectionJSON {
+    aspect: SizeWithUnitAndAspectJSON;
+}
+export interface PrivateRectangularLocationSelection {
+    fromJSON(JSON: RectangularLocationSelectionJSON): RectangularLocationSelection;
+}
+export declare class RectangularLocationSelection extends DefaultSerializeable implements LocationSelection {
+    private type;
+    private _sizeWithUnitAndAspect;
+    get sizeWithUnitAndAspect(): SizeWithUnitAndAspect;
+    static withSize(size: SizeWithUnit): RectangularLocationSelection;
+    static withWidthAndAspectRatio(width: NumberWithUnit, heightToWidthAspectRatio: number): RectangularLocationSelection;
+    static withHeightAndAspectRatio(height: NumberWithUnit, widthToHeightAspectRatio: number): RectangularLocationSelection;
+    static fromJSON(rectangularLocationSelectionJSON: RectangularLocationSelectionJSON): RectangularLocationSelection;
+}

package/dist/dts/locationselection/index.d.ts

@@ -0,0 +1,6 @@
+export { LocationSelection } from "./LocationSelection";
+export { NoneLocationSelection } from "./NoneLocationSelection";
+export { RadiusLocationSelection } from "./RadiusLocationSelection";
+export { RectangularLocationSelection } from "./RectangularLocationSelection";
+export { PrivateRadiusLocationSelection, RadiusLocationSelectionJSON } from "./RadiusLocationSelection";
+export { PrivateRectangularLocationSelection, RectangularLocationSelectionJSON } from "./RectangularLocationSelection";

package/dist/dts/serializable/DefaultSerializable.d.ts

@@ -0,0 +1,4 @@
+import { Serializeable } from "./Serializable";
+export declare class DefaultSerializeable implements Serializeable {
+    toJSON(): object;
+}

package/dist/dts/serializable/Serializable.d.ts

@@ -0,0 +1,3 @@
+export interface Serializeable {
+    toJSON: () => object;
+}

package/dist/dts/serializable/StringSerializable.d.ts

@@ -0,0 +1,3 @@
+export interface StringSerializeable {
+    toJSON: () => string;
+}

package/dist/dts/serializable/ignoreFromSerialization.d.ts

@@ -0,0 +1 @@
+export declare function ignoreFromSerialization(target: any, propertyName: string): void;

package/dist/dts/serializable/ignoreFromSerializationIfNull.d.ts

@@ -0,0 +1 @@
+export declare function ignoreFromSerializationIfNull(target: any, propertyName: string): void;

package/dist/dts/serializable/index.d.ts

@@ -0,0 +1,7 @@
+export { Serializeable } from "./Serializable";
+export { StringSerializeable } from "./StringSerializable";
+export { ignoreFromSerialization } from "./ignoreFromSerialization";
+export { nameForSerialization } from "./nameForSerialization";
+export { ignoreFromSerializationIfNull } from "./ignoreFromSerializationIfNull";
+export { serializationDefault } from "./serializationDefault";
+export { DefaultSerializeable } from "./DefaultSerializable";

package/dist/dts/serializable/nameForSerialization.d.ts

@@ -0,0 +1 @@
+export declare function nameForSerialization(customName: string): (target: any, propertyName: string) => void;

package/dist/dts/serializable/serializationDefault.d.ts

@@ -0,0 +1 @@
+export declare function serializationDefault(defaultValue: any): (target: any, propertyName: string) => void;

package/dist/dts/view/Control.d.ts

@@ -0,0 +1,6 @@
+import { BaseDataCaptureView } from "./DataCaptureView";
+export interface Control {
+}
+export interface PrivateControl {
+    view: BaseDataCaptureView | null;
+}

package/dist/dts/view/DataCaptureOverlay.d.ts

@@ -0,0 +1,6 @@
+import { BaseDataCaptureView } from "./DataCaptureView";
+export interface DataCaptureOverlay {
+}
+export interface PrivateDataCaptureOverlay {
+    view: BaseDataCaptureView | null;
+}

package/dist/dts/view/DataCaptureView.d.ts

@@ -0,0 +1,44 @@
+import { DefaultSerializeable } from "../serializable";
+import { DataCaptureContext } from "../context";
+import { MarginsWithUnit, PointWithUnit, Anchor, Point, Quadrilateral, Rect } from "../common";
+import { FocusGesture, LogoStyle, ZoomGesture } from "../camera";
+import { Control } from "./Control";
+import { DataCaptureOverlay } from "./DataCaptureOverlay";
+import { DataCaptureViewListener } from "./DataCaptureViewListener";
+export interface DataCaptureView {
+}
+export declare class BaseDataCaptureView extends DefaultSerializeable {
+    private _context;
+    viewComponent: DataCaptureView;
+    get context(): DataCaptureContext | null;
+    set context(context: DataCaptureContext | null);
+    private get coreDefaults();
+    scanAreaMargins: MarginsWithUnit;
+    pointOfInterest: PointWithUnit;
+    logoAnchor: Anchor;
+    logoOffset: PointWithUnit;
+    focusGesture: FocusGesture | null;
+    zoomGesture: ZoomGesture | null;
+    logoStyle: LogoStyle;
+    private overlays;
+    private controls;
+    private controller;
+    listeners: DataCaptureViewListener[];
+    private get privateContext();
+    static forContext(context: DataCaptureContext | null): BaseDataCaptureView;
+    constructor();
+    addOverlay(overlay: DataCaptureOverlay): void;
+    removeOverlay(overlay: DataCaptureOverlay): void;
+    addListener(listener: DataCaptureViewListener): void;
+    removeListener(listener: DataCaptureViewListener): void;
+    viewPointForFramePoint(point: Point): Promise<Point>;
+    viewQuadrilateralForFrameQuadrilateral(quadrilateral: Quadrilateral): Promise<Quadrilateral>;
+    addControl(control: Control): void;
+    removeControl(control: Control): void;
+    controlUpdated(): void;
+    dispose(): void;
+    setFrame(frame: Rect, isUnderContent?: boolean): Promise<void>;
+    setPositionAndSize(top: number, left: number, width: number, height: number, shouldBeUnderWebView: boolean): Promise<void>;
+    show(): Promise<void>;
+    hide(): Promise<void>;
+}