scandit-datacapture-frameworks-core 8.2.1 → 8.3.0

package/dist/index.js

@@ -391,6 +391,50 @@ class FactoryMaker {
 }
 FactoryMaker.instances = new Map();
 
+var FocusGestureListenerEvents;
+(function (FocusGestureListenerEvents) {
+    FocusGestureListenerEvents["onFocusGesture"] = "FocusGestureListener.onFocusGesture";
+})(FocusGestureListenerEvents || (FocusGestureListenerEvents = {}));
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
 function ignoreFromSerialization(target, propertyName) {
     target.ignoredProperties = target.ignoredProperties || [];
     target.ignoredProperties.push(propertyName);
@@ -462,8 +506,46 @@ class TapToFocus extends DefaultSerializeable {
     constructor() {
         super();
         this.type = 'tapToFocus';
+        this.showUIIndicator = true;
+        this.listeners = [];
+    }
+    addListener(listener) {
+        if (!this.listeners.includes(listener)) {
+            const wasEmpty = this.listeners.length === 0;
+            this.listeners.push(listener);
+            if (wasEmpty && this.onListenersChanged) {
+                this.onListenersChanged();
+            }
+        }
+    }
+    removeListener(listener) {
+        if (this.listeners.includes(listener)) {
+            this.listeners.splice(this.listeners.indexOf(listener), 1);
+            if (this.listeners.length === 0 && this.onListenersChanged) {
+                this.onListenersChanged();
+            }
+        }
+    }
+    triggerFocus(point) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._controller) {
+                yield this._controller.triggerFocus(point);
+            }
+        });
     }
 }
+__decorate([
+    nameForSerialization('showUIIndicator')
+], TapToFocus.prototype, "showUIIndicator", void 0);
+__decorate([
+    ignoreFromSerialization
+], TapToFocus.prototype, "listeners", void 0);
+__decorate([
+    ignoreFromSerialization
+], TapToFocus.prototype, "onListenersChanged", void 0);
+__decorate([
+    ignoreFromSerialization
+], TapToFocus.prototype, "_controller", void 0);
 
 class PrivateFocusGestureDeserializer {
     static fromJSON(json) {
@@ -480,8 +562,49 @@ class SwipeToZoom extends DefaultSerializeable {
     constructor() {
         super();
         this.type = 'swipeToZoom';
+        this.listeners = [];
+    }
+    addListener(listener) {
+        if (!this.listeners.includes(listener)) {
+            const wasEmpty = this.listeners.length === 0;
+            this.listeners.push(listener);
+            if (wasEmpty && this.onListenersChanged) {
+                this.onListenersChanged();
+            }
+        }
+    }
+    removeListener(listener) {
+        if (this.listeners.includes(listener)) {
+            this.listeners.splice(this.listeners.indexOf(listener), 1);
+            if (this.listeners.length === 0 && this.onListenersChanged) {
+                this.onListenersChanged();
+            }
+        }
+    }
+    triggerZoomIn() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._controller) {
+                yield this._controller.triggerZoomIn();
+            }
+        });
+    }
+    triggerZoomOut() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._controller) {
+                yield this._controller.triggerZoomOut();
+            }
+        });
     }
 }
+__decorate([
+    ignoreFromSerialization
+], SwipeToZoom.prototype, "listeners", void 0);
+__decorate([
+    ignoreFromSerialization
+], SwipeToZoom.prototype, "onListenersChanged", void 0);
+__decorate([
+    ignoreFromSerialization
+], SwipeToZoom.prototype, "_controller", void 0);
 
 class PrivateZoomGestureDeserializer {
     static fromJSON(json) {
@@ -494,44 +617,11 @@ class PrivateZoomGestureDeserializer {
     }
 }
 
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
-
-
-function __decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
+var ZoomGestureListenerEvents;
+(function (ZoomGestureListenerEvents) {
+    ZoomGestureListenerEvents["onZoomInGesture"] = "ZoomGestureListener.onZoomInGesture";
+    ZoomGestureListenerEvents["onZoomOutGesture"] = "ZoomGestureListener.onZoomOutGesture";
+})(ZoomGestureListenerEvents || (ZoomGestureListenerEvents = {}));
 
 var CameraPosition;
 (function (CameraPosition) {
@@ -545,6 +635,16 @@ var FrameSourceListenerEvents;
     FrameSourceListenerEvents["didChangeState"] = "FrameSourceListener.onStateChanged";
 })(FrameSourceListenerEvents || (FrameSourceListenerEvents = {}));
 
+var TorchListenerEvents;
+(function (TorchListenerEvents) {
+    TorchListenerEvents["didChangeTorchToState"] = "TorchListener.onTorchStateChanged";
+})(TorchListenerEvents || (TorchListenerEvents = {}));
+
+var MacroModeListenerEvents;
+(function (MacroModeListenerEvents) {
+    MacroModeListenerEvents["didChangeMacroMode"] = "MacroModeListener.onMacroModeChanged";
+})(MacroModeListenerEvents || (MacroModeListenerEvents = {}));
+
 var FrameSourceState;
 (function (FrameSourceState) {
     FrameSourceState["On"] = "on";
@@ -1179,8 +1279,7 @@ class Color {
         return new Color(Color.normalizeHex(hex));
     }
     static fromRGBA(red, green, blue, alpha = 1) {
-        const hexString = [red, green, blue, this.normalizeAlpha(alpha)]
-            .reduce((hex, colorComponent) => hex + this.numberToHex(colorComponent), '');
+        const hexString = [red, green, blue, this.normalizeAlpha(alpha)].reduce((hex, colorComponent) => hex + this.numberToHex(colorComponent), '');
         return new Color(hexString);
     }
     static hexToNumber(hex) {
@@ -1204,13 +1303,16 @@ class Color {
         }
         // double digits if single digit
         if (hex.length < 6) {
-            hex = hex.split('').map(s => s + s).join('');
+            hex = hex
+                .split('')
+                .map(s => s + s)
+                .join('');
         }
         // add alpha if missing
         if (hex.length === 6) {
             hex = hex + 'FF';
         }
-        return '#' + hex.toUpperCase();
+        return hex.toUpperCase();
     }
     static normalizeAlpha(alpha) {
         if (alpha > 0 && alpha <= 1) {
@@ -1226,7 +1328,7 @@ class Color {
         return Color.fromHex(newHex);
     }
     toJSON() {
-        return this.hexadecimalString;
+        return '#' + this.hexadecimalString;
     }
 }
 
@@ -1297,6 +1399,11 @@ var ScanIntention;
     ScanIntention["SmartSelection"] = "smartSelection";
 })(ScanIntention || (ScanIntention = {}));
 
+/**
+ * Symbol returned by parseIfShouldHandle when an event should be skipped
+ * (filtered out based on viewId/modeId mismatch).
+ */
+const SKIP = Symbol('EventDataParser.SKIP');
 class EventDataParser {
     static parse(data) {
         if (data == null) {
@@ -1304,6 +1411,58 @@ class EventDataParser {
         }
         return JSON.parse(data);
     }
+    /**
+     * Check if an event should be handled based on viewId/modeId filtering.
+     * Used by React Native new architecture for pre-parse filtering to avoid
+     * unnecessary JSON parsing of events not intended for this consumer.
+     *
+     * @param ev The event payload to check
+     * @param ids Object containing optional viewId and/or modeId to match against
+     * @returns true if the event should be handled, false if it should be skipped
+     */
+    static shouldHandle(ev, ids) {
+        // If event has no filter fields (old arch, Cordova, Capacitor), proceed to parse
+        if (ev.viewId === undefined && ev.modeId === undefined) {
+            return true;
+        }
+        // Check viewId match if both are specified
+        if (ids.viewId !== undefined && ev.viewId !== undefined && ev.viewId !== ids.viewId) {
+            return false;
+        }
+        // Check modeId match if both are specified
+        if (ids.modeId !== undefined && ev.modeId !== undefined && ev.modeId !== ids.modeId) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Parse event data if it should be handled, otherwise return SKIP.
+     *
+     * Filtering is performed in two stages:
+     * 1. Pre-parse: if the event wrapper carries viewId/modeId, skip parsing entirely on mismatch.
+     * 2. Post-parse: verify the parsed payload's viewId/modeId matches the expected ids.
+     *
+     * @param ev The event payload to check and parse
+     * @param ids Object containing optional viewId and/or modeId to match against
+     * @returns SKIP if filtered out, null if parse failed, or parsed data
+     */
+    static parseIfShouldHandle(ev, ids) {
+        if (!this.shouldHandle(ev, ids)) {
+            return SKIP;
+        }
+        const parsed = this.parse(ev.data);
+        if (parsed === null) {
+            return null;
+        }
+        const data = parsed;
+        if (ids.modeId !== undefined && data.modeId !== undefined && data.modeId !== ids.modeId) {
+            return SKIP;
+        }
+        if (ids.viewId !== undefined && data.viewId !== undefined && data.viewId !== ids.viewId) {
+            return SKIP;
+        }
+        return parsed;
+    }
 }
 
 class Observable extends DefaultSerializeable {
@@ -1442,6 +1601,19 @@ class CoreProxyAdapter {
             return result.data === 'true';
         });
     }
+    /**
+     * Checks if macro mode is available for the current device
+     */
+    isMacroModeAvailable() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.proxy.$executeCore({
+                moduleName: 'CoreModule',
+                methodName: 'isMacroModeAvailable',
+                isEventRegistration: false,
+            });
+            return result.data === 'true';
+        });
+    }
     /**
      * Registers a persistent listener for frame source state change events
      */
@@ -1468,6 +1640,58 @@ class CoreProxyAdapter {
             return result;
         });
     }
+    /**
+     * Registers a persistent listener for torch state change events
+     */
+    registerTorchStateListener() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.proxy.$executeCore({
+                moduleName: 'CoreModule',
+                methodName: 'registerTorchStateListener',
+                isEventRegistration: true,
+            });
+            return result;
+        });
+    }
+    /**
+     * Unregisters the torch state event listener
+     */
+    unregisterTorchStateListener() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.proxy.$executeCore({
+                moduleName: 'CoreModule',
+                methodName: 'unregisterTorchStateListener',
+                isEventRegistration: false,
+            });
+            return result;
+        });
+    }
+    /**
+     * Registers a persistent listener for macro mode change events
+     */
+    registerMacroModeListener() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.proxy.$executeCore({
+                moduleName: 'CoreModule',
+                methodName: 'registerMacroModeListener',
+                isEventRegistration: true,
+            });
+            return result;
+        });
+    }
+    /**
+     * Unregisters the macro mode event listener
+     */
+    unregisterMacroModeListener() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.proxy.$executeCore({
+                moduleName: 'CoreModule',
+                methodName: 'unregisterMacroModeListener',
+                isEventRegistration: false,
+            });
+            return result;
+        });
+    }
     /**
      * Gets the last frame data by frame ID as JSON
      * @param frameId Unique frame identifier
@@ -1689,6 +1913,113 @@ class CoreProxyAdapter {
             return result;
         });
     }
+    /**
+     * Registers a persistent listener for focus gesture events
+     * @param viewId View identifier
+     */
+    registerFocusGestureListener(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ viewId }) {
+            const result = yield this.proxy.$executeCore({
+                moduleName: 'CoreModule',
+                methodName: 'registerFocusGestureListener',
+                isEventRegistration: true,
+                viewId,
+            });
+            return result;
+        });
+    }
+    /**
+     * Unregisters the focus gesture event listener
+     * @param viewId View identifier
+     */
+    unregisterFocusGestureListener(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ viewId }) {
+            const result = yield this.proxy.$executeCore({
+                moduleName: 'CoreModule',
+                methodName: 'unregisterFocusGestureListener',
+                isEventRegistration: false,
+                viewId,
+            });
+            return result;
+        });
+    }
+    /**
+     * Triggers a focus as if the focus gesture was performed
+     * @param viewId View identifier
+     * @param pointJson Point in view coordinates as JSON string
+     */
+    triggerFocus(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ viewId, pointJson }) {
+            const result = yield this.proxy.$executeCore({
+                moduleName: 'CoreModule',
+                methodName: 'triggerFocus',
+                isEventRegistration: false,
+                viewId,
+                pointJson,
+            });
+            return result;
+        });
+    }
+    /**
+     * Triggers a zoom in gesture as if the zoom gesture was performed
+     * @param viewId View identifier
+     */
+    triggerZoomIn(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ viewId }) {
+            const result = yield this.proxy.$executeCore({
+                moduleName: 'CoreModule',
+                methodName: 'triggerZoomIn',
+                isEventRegistration: false,
+                viewId,
+            });
+            return result;
+        });
+    }
+    /**
+     * Triggers a zoom out gesture as if the zoom gesture was performed
+     * @param viewId View identifier
+     */
+    triggerZoomOut(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ viewId }) {
+            const result = yield this.proxy.$executeCore({
+                moduleName: 'CoreModule',
+                methodName: 'triggerZoomOut',
+                isEventRegistration: false,
+                viewId,
+            });
+            return result;
+        });
+    }
+    /**
+     * Registers a persistent listener for zoom gesture events
+     * @param viewId View identifier
+     */
+    registerZoomGestureListener(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ viewId }) {
+            const result = yield this.proxy.$executeCore({
+                moduleName: 'CoreModule',
+                methodName: 'registerZoomGestureListener',
+                isEventRegistration: true,
+                viewId,
+            });
+            return result;
+        });
+    }
+    /**
+     * Unregisters the zoom gesture event listener
+     * @param viewId View identifier
+     */
+    unregisterZoomGestureListener(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ viewId }) {
+            const result = yield this.proxy.$executeCore({
+                moduleName: 'CoreModule',
+                methodName: 'unregisterZoomGestureListener',
+                isEventRegistration: false,
+                viewId,
+            });
+            return result;
+        });
+    }
     /**
      * Updates the DataCaptureView configuration
      * @param viewJson Updated view configuration as JSON string
@@ -1767,7 +2098,10 @@ class ImageFrameSourceController extends BaseController {
         this._proxy.dispose();
     }
     handleDidChangeStateEvent(ev) {
-        const event = EventDataParser.parse(ev.data);
+        const event = EventDataParser.parseIfShouldHandle(ev, {});
+        if (event === SKIP) {
+            return;
+        }
         if (event === null) {
             console.error('ImageFrameSourceController didChangeState payload is null');
             return;
@@ -1869,10 +2203,17 @@ class PrivateFrameData {
     get imageBuffers() {
         return this._imageBuffers;
     }
+    get imageBuffer() {
+        return this._imageBuffers[0];
+    }
     get orientation() {
         return this._orientation;
     }
+    get timestamp() {
+        return this._timestamp;
+    }
     static fromJSON(json) {
+        var _a;
         const frameData = new PrivateFrameData();
         frameData._imageBuffers = json.imageBuffers.map((imageBufferJSON) => {
             const imageBuffer = new ImageBuffer();
@@ -1882,12 +2223,14 @@ class PrivateFrameData {
             return imageBuffer;
         });
         frameData._orientation = json.orientation;
+        frameData._timestamp = (_a = json.timestamp) !== null && _a !== void 0 ? _a : -1;
         return frameData;
     }
     static empty() {
         const frameData = new PrivateFrameData();
         frameData._imageBuffers = [];
         frameData._orientation = 90;
+        frameData._timestamp = -1;
         return frameData;
     }
 }
@@ -1972,14 +2315,18 @@ class Camera extends DefaultSerializeable {
         this.settings = null;
         this._desiredTorchState = TorchState.Off;
         this._desiredState = FrameSourceState.Off;
+        this._hasTorchStateListeners = false;
+        this._hasMacroModeListeners = false;
         this.currentCameraState = FrameSourceState.Off;
         this.listeners = [];
+        this.torchListeners = [];
+        this.macroModeListeners = [];
         this._context = null;
         this.nativeReadyResolver = null;
         this.nativeReadyRejecter = null;
         this.nativeReadyPromise = null;
         this.nativeReadyTimeout = null;
-        this.position = position || Camera.coreDefaults.Camera.defaultPosition;
+        this._position = position || Camera.coreDefaults.Camera.defaultPosition;
         this.settings = settings || null;
         this._desiredTorchState = desiredTorchState || TorchState.Off;
         this._desiredState = desiredState || FrameSourceState.Off;
@@ -2027,6 +2374,58 @@ class Camera extends DefaultSerializeable {
         }
         this.listeners.splice(this.listeners.indexOf(listener), 1);
     }
+    addTorchListener(listener) {
+        if (this.torchListeners.includes(listener)) {
+            return;
+        }
+        this.torchListeners.push(listener);
+        this._hasTorchStateListeners = this.torchListeners.length > 0;
+        if (this.torchListeners.length === 1) {
+            void this.controller.subscribeTorchListener();
+        }
+        if (this.isActiveCamera) {
+            void this.didChange();
+        }
+    }
+    removeTorchListener(listener) {
+        if (!this.torchListeners.includes(listener)) {
+            return;
+        }
+        this.torchListeners.splice(this.torchListeners.indexOf(listener), 1);
+        this._hasTorchStateListeners = this.torchListeners.length > 0;
+        if (this.torchListeners.length === 0) {
+            void this.controller.unsubscribeTorchListener();
+        }
+        if (this.isActiveCamera) {
+            void this.didChange();
+        }
+    }
+    addMacroModeListener(listener) {
+        if (this.macroModeListeners.includes(listener)) {
+            return;
+        }
+        this.macroModeListeners.push(listener);
+        this._hasMacroModeListeners = this.macroModeListeners.length > 0;
+        if (this.macroModeListeners.length === 1) {
+            void this.controller.subscribeMacroModeListener();
+        }
+        if (this.isActiveCamera) {
+            void this.didChange();
+        }
+    }
+    removeMacroModeListener(listener) {
+        if (!this.macroModeListeners.includes(listener)) {
+            return;
+        }
+        this.macroModeListeners.splice(this.macroModeListeners.indexOf(listener), 1);
+        this._hasMacroModeListeners = this.macroModeListeners.length > 0;
+        if (this.macroModeListeners.length === 0) {
+            void this.controller.unsubscribeMacroModeListener();
+        }
+        if (this.isActiveCamera) {
+            void this.didChange();
+        }
+    }
     applySettings(settings) {
         return __awaiter(this, void 0, void 0, function* () {
             this.settings = settings;
@@ -2096,6 +2495,22 @@ class Camera extends DefaultSerializeable {
         }
         return Camera.atPosition(defaultPosition);
     }
+    static isMacroModeAvailable() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const proxy = FactoryMaker.getInstance('CoreProxy');
+            if (!proxy) {
+                return false;
+            }
+            const adapter = new CoreProxyAdapter(proxy);
+            return yield adapter.isMacroModeAvailable();
+        });
+    }
+    get position() {
+        return this._position;
+    }
+    get isTorchAvailable() {
+        return this.controller.getIsTorchAvailable();
+    }
     get desiredState() {
         return this._desiredState;
     }
@@ -2138,18 +2553,33 @@ __decorate([
 __decorate([
     serializationDefault({})
 ], Camera.prototype, "settings", void 0);
+__decorate([
+    nameForSerialization('position')
+], Camera.prototype, "_position", void 0);
 __decorate([
     nameForSerialization('desiredTorchState')
 ], Camera.prototype, "_desiredTorchState", void 0);
 __decorate([
     nameForSerialization('desiredState')
 ], Camera.prototype, "_desiredState", void 0);
+__decorate([
+    nameForSerialization('hasTorchStateListeners')
+], Camera.prototype, "_hasTorchStateListeners", void 0);
+__decorate([
+    nameForSerialization('hasMacroModeListeners')
+], Camera.prototype, "_hasMacroModeListeners", void 0);
 __decorate([
     ignoreFromSerialization
 ], Camera.prototype, "currentCameraState", void 0);
 __decorate([
     ignoreFromSerialization
 ], Camera.prototype, "listeners", void 0);
+__decorate([
+    ignoreFromSerialization
+], Camera.prototype, "torchListeners", void 0);
+__decorate([
+    ignoreFromSerialization
+], Camera.prototype, "macroModeListeners", void 0);
 __decorate([
     ignoreFromSerialization
 ], Camera.prototype, "_context", void 0);
@@ -2466,6 +2896,14 @@ class CameraController extends BaseController {
         this.handleDidChangeStateEventWrapper = (ev) => {
             return this.handleDidChangeStateEvent(ev);
         };
+        // Arrow function wrapper to avoid .bind(this) and always use current class state
+        this.handleDidChangeTorchToStateEventWrapper = (ev) => {
+            return this.handleDidChangeTorchToStateEvent(ev);
+        };
+        // Arrow function wrapper to avoid .bind(this) and always use current class state
+        this.handleDidChangeMacroModeEventWrapper = (ev) => {
+            return this.handleDidChangeMacroModeEvent(ev);
+        };
         this.camera = camera;
         this.adapter = new CoreProxyAdapter(this._proxy);
         void this.subscribeListener();
@@ -2476,14 +2914,14 @@ class CameraController extends BaseController {
     getCurrentState() {
         return __awaiter(this, void 0, void 0, function* () {
             return yield this.adapter.getCameraState({
-                cameraPosition: JSON.stringify(this.privateCamera.position)
+                cameraPosition: JSON.stringify(this.privateCamera._position)
             });
         });
     }
     getIsTorchAvailable() {
         return __awaiter(this, void 0, void 0, function* () {
             return yield this.adapter.isTorchAvailable({
-                cameraPosition: JSON.stringify(this.privateCamera.position)
+                cameraPosition: JSON.stringify(this.privateCamera._position)
             });
         });
     }
@@ -2508,20 +2946,78 @@ class CameraController extends BaseController {
             this._proxy.eventEmitter.off(FrameSourceListenerEvents.didChangeState, this.handleDidChangeStateEventWrapper);
         });
     }
+    subscribeTorchListener() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.adapter.registerTorchStateListener();
+            this._proxy.subscribeForEvents([TorchListenerEvents.didChangeTorchToState]);
+            this._proxy.eventEmitter.on(TorchListenerEvents.didChangeTorchToState, this.handleDidChangeTorchToStateEventWrapper);
+        });
+    }
+    unsubscribeTorchListener() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.adapter.unregisterTorchStateListener();
+            this._proxy.unsubscribeFromEvents([TorchListenerEvents.didChangeTorchToState]);
+            this._proxy.eventEmitter.off(TorchListenerEvents.didChangeTorchToState, this.handleDidChangeTorchToStateEventWrapper);
+        });
+    }
+    subscribeMacroModeListener() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.adapter.registerMacroModeListener();
+            this._proxy.subscribeForEvents([MacroModeListenerEvents.didChangeMacroMode]);
+            this._proxy.eventEmitter.on(MacroModeListenerEvents.didChangeMacroMode, this.handleDidChangeMacroModeEventWrapper);
+        });
+    }
+    unsubscribeMacroModeListener() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.adapter.unregisterMacroModeListener();
+            this._proxy.unsubscribeFromEvents([MacroModeListenerEvents.didChangeMacroMode]);
+            this._proxy.eventEmitter.off(MacroModeListenerEvents.didChangeMacroMode, this.handleDidChangeMacroModeEventWrapper);
+        });
+    }
     dispose() {
         void this.unsubscribeListener();
+        void this.unsubscribeTorchListener();
+        void this.unsubscribeMacroModeListener();
         this._proxy.dispose();
     }
     handleDidChangeStateEvent(ev) {
-        const event = EventDataParser.parse(ev.data);
-        if (event) {
-            if (event.cameraPosition !== this.privateCamera.position || !this.privateCamera.isActiveCamera) {
-                return;
-            }
-            this.privateCamera.currentCameraState = event.state;
-            this.privateCamera.listeners.forEach(listener => {
+        const event = EventDataParser.parseIfShouldHandle(ev, {});
+        if (event === SKIP || event === null) {
+            return;
+        }
+        if (event.cameraPosition !== this.privateCamera._position || !this.privateCamera.isActiveCamera) {
+            return;
+        }
+        this.privateCamera.currentCameraState = event.state;
+        this.privateCamera.listeners.forEach(listener => {
+            var _a;
+            (_a = listener === null || listener === void 0 ? void 0 : listener.didChangeState) === null || _a === void 0 ? void 0 : _a.call(listener, this.camera, this.privateCamera._desiredState);
+        });
+    }
+    handleDidChangeTorchToStateEvent(ev) {
+        const event = EventDataParser.parseIfShouldHandle(ev, {});
+        if (event === SKIP || event === null) {
+            return;
+        }
+        if (this.privateCamera.isActiveCamera) {
+            const torchState = event.state;
+            this.privateCamera.desiredTorchState = torchState;
+            this.privateCamera.torchListeners.forEach(listener => {
                 var _a;
-                (_a = listener === null || listener === void 0 ? void 0 : listener.didChangeState) === null || _a === void 0 ? void 0 : _a.call(listener, this.camera, this.privateCamera._desiredState);
+                (_a = listener === null || listener === void 0 ? void 0 : listener.didChangeTorchToState) === null || _a === void 0 ? void 0 : _a.call(listener, torchState);
+            });
+        }
+    }
+    handleDidChangeMacroModeEvent(ev) {
+        const event = EventDataParser.parseIfShouldHandle(ev, {});
+        if (event === SKIP || event === null) {
+            return;
+        }
+        if (this.privateCamera.isActiveCamera) {
+            const macroMode = event.macroMode;
+            this.privateCamera.macroModeListeners.forEach(listener => {
+                var _a;
+                (_a = listener === null || listener === void 0 ? void 0 : listener.didChangeMacroMode) === null || _a === void 0 ? void 0 : _a.call(listener, macroMode);
             });
         }
     }
@@ -2737,7 +3233,10 @@ class DataCaptureContextController extends BaseController {
         });
     }
     handleDidChangeStatusEvent(eventPayload) {
-        const event = EventDataParser.parse(eventPayload.data);
+        const event = EventDataParser.parseIfShouldHandle(eventPayload, {});
+        if (event === SKIP) {
+            return;
+        }
         if (event === null) {
             console.error('DataCaptureContextController didChangeStatus payload is null');
             return;
@@ -2994,11 +3493,23 @@ __decorate([
 var DataCaptureViewEvents;
 (function (DataCaptureViewEvents) {
     DataCaptureViewEvents["didChangeSize"] = "DataCaptureViewListener.onSizeChanged";
+    DataCaptureViewEvents["onFocusGesture"] = "FocusGestureListener.onFocusGesture";
 })(DataCaptureViewEvents || (DataCaptureViewEvents = {}));
 class DataCaptureViewController extends BaseController {
     constructor(view) {
         super('DataCaptureViewProxy');
         this._listenerRegistered = false;
+        this._focusGestureListenerRegistered = false;
+        this._zoomGestureListenerRegistered = false;
+        this.handleOnFocusGestureEventWrapper = (eventPayload) => {
+            return this.handleOnFocusGestureEvent(eventPayload);
+        };
+        this.handleOnZoomInGestureEventWrapper = (eventPayload) => {
+            return this.handleOnZoomInGestureEvent(eventPayload);
+        };
+        this.handleOnZoomOutGestureEventWrapper = (eventPayload) => {
+            return this.handleOnZoomOutGestureEvent(eventPayload);
+        };
         // Arrow function wrapper to avoid .bind(this) and always use current class state
         this.handleDidChangeSizeEventWrapper = (eventPayload) => {
             return this.handleDidChangeSizeEvent(eventPayload);
@@ -3018,6 +3529,21 @@ class DataCaptureViewController extends BaseController {
             return Quadrilateral['fromJSON'](JSON.parse(result));
         });
     }
+    triggerFocus(point) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.adapter.triggerFocus({ viewId: this.view.viewId, pointJson: JSON.stringify(point.toJSON()) });
+        });
+    }
+    triggerZoomIn() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.adapter.triggerZoomIn({ viewId: this.view.viewId });
+        });
+    }
+    triggerZoomOut() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.adapter.triggerZoomOut({ viewId: this.view.viewId });
+        });
+    }
     setPositionAndSize(top, left, width, height, shouldBeUnderWebView) {
         return this._proxy.$setDataCaptureViewPositionAndSize({ top, left, width, height, shouldBeUnderWebView });
     }
@@ -3047,6 +3573,8 @@ class DataCaptureViewController extends BaseController {
     }
     dispose() {
         void this.unsubscribeListener();
+        void this.unsubscribeFocusGestureListener();
+        void this.unsubscribeZoomGestureListener();
         this._proxy.dispose();
     }
     subscribeListener() {
@@ -3071,16 +3599,168 @@ class DataCaptureViewController extends BaseController {
             this._listenerRegistered = false;
         });
     }
+    updateFocusGestureListenerSubscription(focusGesture, shouldSubscribe) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!focusGesture) {
+                if (this._focusGestureListenerRegistered) {
+                    yield this.unsubscribeFocusGestureListener();
+                }
+                return;
+            }
+            const privateFocusGesture = focusGesture;
+            const hasListeners = privateFocusGesture.listeners && privateFocusGesture.listeners.length > 0;
+            if (shouldSubscribe && hasListeners && !this._focusGestureListenerRegistered) {
+                yield this.subscribeFocusGestureListener();
+            }
+            else if (!hasListeners && this._focusGestureListenerRegistered) {
+                yield this.unsubscribeFocusGestureListener();
+            }
+        });
+    }
+    subscribeFocusGestureListener() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._focusGestureListenerRegistered || !this.isViewCreated()) {
+                return;
+            }
+            yield this.adapter.registerFocusGestureListener({ viewId: this.view.viewId });
+            this._proxy.subscribeForEvents([FocusGestureListenerEvents.onFocusGesture]);
+            this._proxy.eventEmitter.on(FocusGestureListenerEvents.onFocusGesture, this.handleOnFocusGestureEventWrapper);
+            this._focusGestureListenerRegistered = true;
+        });
+    }
+    unsubscribeFocusGestureListener() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._focusGestureListenerRegistered) {
+                return;
+            }
+            yield this.adapter.unregisterFocusGestureListener({ viewId: this.view.viewId });
+            this._proxy.unsubscribeFromEvents([FocusGestureListenerEvents.onFocusGesture]);
+            this._proxy.eventEmitter.off(FocusGestureListenerEvents.onFocusGesture, this.handleOnFocusGestureEventWrapper);
+            this._focusGestureListenerRegistered = false;
+        });
+    }
+    handleOnFocusGestureEvent(eventPayload) {
+        const event = EventDataParser.parseIfShouldHandle(eventPayload, { viewId: this.view.viewId });
+        if (event === SKIP) {
+            return;
+        }
+        if (event === null) {
+            console.error('DataCaptureViewController onFocusGesture payload is null');
+            return;
+        }
+        const focusGesture = this.view.focusGesture;
+        if (!focusGesture) {
+            return;
+        }
+        const privateFocusGesture = focusGesture;
+        if (!privateFocusGesture.listeners || privateFocusGesture.listeners.length === 0) {
+            return;
+        }
+        const point = PointWithUnit['fromJSON'](event.point);
+        privateFocusGesture.listeners.forEach(listener => {
+            if (listener.didFocusGesture) {
+                listener.didFocusGesture(focusGesture, point);
+            }
+        });
+    }
+    updateZoomGestureListenerSubscription(zoomGesture, shouldSubscribe) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!zoomGesture) {
+                if (this._zoomGestureListenerRegistered) {
+                    yield this.unsubscribeZoomGestureListener();
+                }
+                return;
+            }
+            const privateZoomGesture = zoomGesture;
+            const hasListeners = privateZoomGesture.listeners && privateZoomGesture.listeners.length > 0;
+            if (shouldSubscribe && hasListeners && !this._zoomGestureListenerRegistered) {
+                yield this.subscribeZoomGestureListener();
+            }
+            else if (!hasListeners && this._zoomGestureListenerRegistered) {
+                yield this.unsubscribeZoomGestureListener();
+            }
+        });
+    }
+    subscribeZoomGestureListener() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._zoomGestureListenerRegistered || !this.isViewCreated()) {
+                return;
+            }
+            yield this.adapter.registerZoomGestureListener({ viewId: this.view.viewId });
+            this._proxy.subscribeForEvents([ZoomGestureListenerEvents.onZoomInGesture, ZoomGestureListenerEvents.onZoomOutGesture]);
+            this._proxy.eventEmitter.on(ZoomGestureListenerEvents.onZoomInGesture, this.handleOnZoomInGestureEventWrapper);
+            this._proxy.eventEmitter.on(ZoomGestureListenerEvents.onZoomOutGesture, this.handleOnZoomOutGestureEventWrapper);
+            this._zoomGestureListenerRegistered = true;
+        });
+    }
+    unsubscribeZoomGestureListener() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._zoomGestureListenerRegistered) {
+                return;
+            }
+            yield this.adapter.unregisterZoomGestureListener({ viewId: this.view.viewId });
+            this._proxy.unsubscribeFromEvents([ZoomGestureListenerEvents.onZoomInGesture, ZoomGestureListenerEvents.onZoomOutGesture]);
+            this._proxy.eventEmitter.off(ZoomGestureListenerEvents.onZoomInGesture, this.handleOnZoomInGestureEventWrapper);
+            this._proxy.eventEmitter.off(ZoomGestureListenerEvents.onZoomOutGesture, this.handleOnZoomOutGestureEventWrapper);
+            this._zoomGestureListenerRegistered = false;
+        });
+    }
+    handleOnZoomInGestureEvent(eventPayload) {
+        const event = EventDataParser.parseIfShouldHandle(eventPayload, { viewId: this.view.viewId });
+        if (event === SKIP) {
+            return;
+        }
+        if (event === null) {
+            console.error('DataCaptureViewController onZoomInGesture payload is null');
+            return;
+        }
+        const zoomGesture = this.view.zoomGesture;
+        if (!zoomGesture) {
+            return;
+        }
+        const privateZoomGesture = zoomGesture;
+        if (!privateZoomGesture.listeners || privateZoomGesture.listeners.length === 0) {
+            return;
+        }
+        privateZoomGesture.listeners.forEach(listener => {
+            if (listener.didZoomInGesture) {
+                listener.didZoomInGesture(zoomGesture);
+            }
+        });
+    }
+    handleOnZoomOutGestureEvent(eventPayload) {
+        const event = EventDataParser.parseIfShouldHandle(eventPayload, { viewId: this.view.viewId });
+        if (event === SKIP) {
+            return;
+        }
+        if (event === null) {
+            console.error('DataCaptureViewController onZoomOutGesture payload is null');
+            return;
+        }
+        const zoomGesture = this.view.zoomGesture;
+        if (!zoomGesture) {
+            return;
+        }
+        const privateZoomGesture = zoomGesture;
+        if (!privateZoomGesture.listeners || privateZoomGesture.listeners.length === 0) {
+            return;
+        }
+        privateZoomGesture.listeners.forEach(listener => {
+            if (listener.didZoomOutGesture) {
+                listener.didZoomOutGesture(zoomGesture);
+            }
+        });
+    }
     createView() {
         return this._proxy.$createDataCaptureView({ viewJson: JSON.stringify(this.view.toJSON()) });
     }
     handleDidChangeSizeEvent(eventPayload) {
-        const event = EventDataParser.parse(eventPayload.data);
-        if (event === null) {
-            console.error('DataCaptureViewController didChangeSize payload is null');
+        const event = EventDataParser.parseIfShouldHandle(eventPayload, { viewId: this.view.viewId });
+        if (event === SKIP) {
             return;
         }
-        if (event.viewId !== this.view.viewId) {
+        if (event === null) {
+            console.error('DataCaptureViewController didChangeSize payload is null');
             return;
         }
         const size = Size['fromJSON'](event.size);
@@ -3152,14 +3832,42 @@ class BaseDataCaptureView extends DefaultSerializeable {
         return this._focusGesture;
     }
     set focusGesture(newValue) {
+        if (this._focusGesture) {
+            const privateFocusGesture = this._focusGesture;
+            privateFocusGesture.onListenersChanged = undefined;
+            privateFocusGesture._controller = null;
+            void this.controller.updateFocusGestureListenerSubscription(this._focusGesture, false);
+        }
         this._focusGesture = newValue;
+        if (newValue) {
+            const privateFocusGesture = newValue;
+            privateFocusGesture._controller = this.controller;
+            privateFocusGesture.onListenersChanged = () => {
+                void this.controller.updateFocusGestureListenerSubscription(newValue, true);
+            };
+            void this.controller.updateFocusGestureListenerSubscription(newValue, true);
+        }
         void this.controller.updateView();
     }
     get zoomGesture() {
         return this._zoomGesture;
     }
     set zoomGesture(newValue) {
+        if (this._zoomGesture) {
+            const privateZoomGesture = this._zoomGesture;
+            privateZoomGesture.onListenersChanged = undefined;
+            privateZoomGesture._controller = null;
+            void this.controller.updateZoomGestureListenerSubscription(this._zoomGesture, false);
+        }
         this._zoomGesture = newValue;
+        if (newValue) {
+            const privateZoomGesture = newValue;
+            privateZoomGesture._controller = this.controller;
+            privateZoomGesture.onListenersChanged = () => {
+                void this.controller.updateZoomGestureListenerSubscription(newValue, true);
+            };
+            void this.controller.updateZoomGestureListenerSubscription(newValue, true);
+        }
         void this.controller.updateView();
     }
     get logoStyle() {
@@ -3169,6 +3877,13 @@ class BaseDataCaptureView extends DefaultSerializeable {
         this._logoStyle = newValue;
         void this.controller.updateView();
     }
+    get shouldShowZoomNotification() {
+        return this._shouldShowZoomNotification;
+    }
+    set shouldShowZoomNotification(newValue) {
+        this._shouldShowZoomNotification = newValue;
+        void this.controller.updateView();
+    }
     get privateContext() {
         return this.context;
     }
@@ -3178,6 +3893,7 @@ class BaseDataCaptureView extends DefaultSerializeable {
         return view;
     }
     constructor(context) {
+        var _a;
         super();
         this.parentId = null;
         this.overlays = [];
@@ -3194,6 +3910,7 @@ class BaseDataCaptureView extends DefaultSerializeable {
         this._focusGesture = this.coreDefaults.DataCaptureView.focusGesture;
         this._zoomGesture = this.coreDefaults.DataCaptureView.zoomGesture;
         this._logoStyle = this.coreDefaults.DataCaptureView.logoStyle;
+        this._shouldShowZoomNotification = (_a = this.coreDefaults.DataCaptureView.shouldShowZoomNotification) !== null && _a !== void 0 ? _a : true;
         this.controller = new DataCaptureViewController(this);
     }
     addOverlay(overlay) {
@@ -3243,6 +3960,15 @@ class BaseDataCaptureView extends DefaultSerializeable {
     viewQuadrilateralForFrameQuadrilateral(quadrilateral) {
         return this.controller.viewQuadrilateralForFrameQuadrilateral(quadrilateral);
     }
+    triggerFocus(point) {
+        return this.controller.triggerFocus(point);
+    }
+    triggerZoomIn() {
+        return this.controller.triggerZoomIn();
+    }
+    triggerZoomOut() {
+        return this.controller.triggerZoomOut();
+    }
     addControl(control) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.controls.includes(control)) {
@@ -3326,6 +4052,10 @@ class BaseDataCaptureView extends DefaultSerializeable {
         }
         return this.controller.hide();
     }
+    setProperty(name, value) {
+        this[name] = value;
+        void this.controller.updateView();
+    }
 }
 __decorate([
     ignoreFromSerialization
@@ -3367,6 +4097,9 @@ __decorate([
 __decorate([
     nameForSerialization('logoStyle')
 ], BaseDataCaptureView.prototype, "_logoStyle", void 0);
+__decorate([
+    nameForSerialization('shouldShowZoomNotification')
+], BaseDataCaptureView.prototype, "_shouldShowZoomNotification", void 0);
 __decorate([
     ignoreFromSerialization
 ], BaseDataCaptureView.prototype, "controller", void 0);
@@ -3376,7 +4109,7 @@ __decorate([
 
 class ZoomSwitchControl extends DefaultSerializeable {
     constructor() {
-        super(...arguments);
+        super();
         this.type = 'zoom';
         this.icon = {
             zoomedOut: { default: null, pressed: null },
@@ -3385,6 +4118,12 @@ class ZoomSwitchControl extends DefaultSerializeable {
         this.view = null;
         this.anchor = null;
         this.offset = null;
+        this.contentDescriptionWhenZoomedOut = null;
+        this.contentDescriptionWhenZoomedIn = null;
+        this.accessibilityLabelWhenZoomedOut = null;
+        this.accessibilityLabelWhenZoomedIn = null;
+        this.accessibilityHintWhenZoomedOut = null;
+        this.accessibilityHintWhenZoomedIn = null;
     }
     get zoomedOutImage() {
         var _a, _b;
@@ -3461,7 +4200,7 @@ __decorate([
 
 class TorchSwitchControl extends DefaultSerializeable {
     constructor() {
-        super(...arguments);
+        super();
         this.type = 'torch';
         this.icon = {
             on: { default: null, pressed: null },
@@ -3470,6 +4209,10 @@ class TorchSwitchControl extends DefaultSerializeable {
         this.view = null;
         this.anchor = null;
         this.offset = null;
+        this.accessibilityLabelWhenOff = null;
+        this.accessibilityHintWhenOff = null;
+        this.accessibilityLabelWhenOn = null;
+        this.accessibilityHintWhenOn = null;
     }
     get torchOffImage() {
         var _a, _b;
@@ -3551,6 +4294,18 @@ class TorchSwitchControl extends DefaultSerializeable {
 __decorate([
     ignoreFromSerialization
 ], TorchSwitchControl.prototype, "view", void 0);
+__decorate([
+    nameForSerialization('accessibilityLabelWhenOff')
+], TorchSwitchControl.prototype, "accessibilityLabelWhenOff", void 0);
+__decorate([
+    nameForSerialization('accessibilityHintWhenOff')
+], TorchSwitchControl.prototype, "accessibilityHintWhenOff", void 0);
+__decorate([
+    nameForSerialization('accessibilityLabelWhenOn')
+], TorchSwitchControl.prototype, "accessibilityLabelWhenOn", void 0);
+__decorate([
+    nameForSerialization('accessibilityHintWhenOn')
+], TorchSwitchControl.prototype, "accessibilityHintWhenOn", void 0);
 
 var VideoResolution;
 (function (VideoResolution) {
@@ -3605,13 +4360,19 @@ class CameraSettings extends DefaultSerializeable {
         this.focus.shouldPreferSmoothAutoFocus = newShouldPreferSmoothAutoFocus;
     }
     static fromJSON(json) {
+        var _a, _b, _c;
         const settings = new CameraSettings();
         settings.preferredResolution = json.preferredResolution;
         settings.zoomFactor = json.zoomFactor;
-        settings.focusRange = json.focusRange;
         settings.zoomGestureZoomFactor = json.zoomGestureZoomFactor;
+        settings.macroMode = ((_a = json.macroMode) !== null && _a !== void 0 ? _a : CameraSettings.coreDefaults.Camera.Settings.macroMode);
+        settings.adaptiveExposure = (_b = json.adaptiveExposure) !== null && _b !== void 0 ? _b : CameraSettings.coreDefaults.Camera.Settings.adaptiveExposure;
+        settings.torchLevel = (_c = json.torchLevel) !== null && _c !== void 0 ? _c : CameraSettings.coreDefaults.Camera.Settings.torchLevel;
+        settings.focusRange = json.focusRange;
         settings.focusGestureStrategy = json.focusGestureStrategy;
         settings.shouldPreferSmoothAutoFocus = json.shouldPreferSmoothAutoFocus;
+        // manualLensPosition, focusStrategy (and on iOS: range) arrive in the properties bag
+        // and are routed to the focus bag by setProperty via focusHiddenProperties
         if (json.properties !== undefined) {
             for (const key of Object.keys(json.properties)) {
                 settings.setProperty(key, json.properties[key]);
@@ -3620,11 +4381,14 @@ class CameraSettings extends DefaultSerializeable {
         return settings;
     }
     constructor(settings) {
-        var _a, _b, _c, _d, _e, _f;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
         super();
         this.preferredResolution = CameraSettings.coreDefaults.Camera.Settings.preferredResolution;
         this.zoomFactor = CameraSettings.coreDefaults.Camera.Settings.zoomFactor;
         this.zoomGestureZoomFactor = CameraSettings.coreDefaults.Camera.Settings.zoomGestureZoomFactor;
+        this.torchLevel = CameraSettings.coreDefaults.Camera.Settings.torchLevel;
+        this.macroMode = CameraSettings.coreDefaults.Camera.Settings.macroMode;
+        this.adaptiveExposure = CameraSettings.coreDefaults.Camera.Settings.adaptiveExposure;
         this.focusHiddenProperties = [
             'range',
             'manualLensPosition',
@@ -3635,15 +4399,22 @@ class CameraSettings extends DefaultSerializeable {
         this.focus = {
             range: CameraSettings.coreDefaults.Camera.Settings.focusRange,
             focusGestureStrategy: CameraSettings.coreDefaults.Camera.Settings.focusGestureStrategy,
-            shouldPreferSmoothAutoFocus: CameraSettings.coreDefaults.Camera.Settings.shouldPreferSmoothAutoFocus
+            shouldPreferSmoothAutoFocus: CameraSettings.coreDefaults.Camera.Settings.shouldPreferSmoothAutoFocus,
+            manualLensPosition: CameraSettings.coreDefaults.Camera.Settings.manualLensPosition,
+            focusStrategy: CameraSettings.coreDefaults.Camera.Settings.focusStrategy,
         };
         this.preferredResolution = (_a = settings === null || settings === void 0 ? void 0 : settings.preferredResolution) !== null && _a !== void 0 ? _a : CameraSettings.coreDefaults.Camera.Settings.preferredResolution;
         this.zoomFactor = (_b = settings === null || settings === void 0 ? void 0 : settings.zoomFactor) !== null && _b !== void 0 ? _b : CameraSettings.coreDefaults.Camera.Settings.zoomFactor;
         this.zoomGestureZoomFactor = (_c = settings === null || settings === void 0 ? void 0 : settings.zoomGestureZoomFactor) !== null && _c !== void 0 ? _c : CameraSettings.coreDefaults.Camera.Settings.zoomGestureZoomFactor;
+        this.torchLevel = (_d = settings === null || settings === void 0 ? void 0 : settings.torchLevel) !== null && _d !== void 0 ? _d : CameraSettings.coreDefaults.Camera.Settings.torchLevel;
+        this.macroMode = (_e = settings === null || settings === void 0 ? void 0 : settings.macroMode) !== null && _e !== void 0 ? _e : CameraSettings.coreDefaults.Camera.Settings.macroMode;
+        this.adaptiveExposure = (_f = settings === null || settings === void 0 ? void 0 : settings.adaptiveExposure) !== null && _f !== void 0 ? _f : CameraSettings.coreDefaults.Camera.Settings.adaptiveExposure;
         this.focus = {
-            range: (_d = settings === null || settings === void 0 ? void 0 : settings.focusRange) !== null && _d !== void 0 ? _d : CameraSettings.coreDefaults.Camera.Settings.focusRange,
-            focusGestureStrategy: (_e = settings === null || settings === void 0 ? void 0 : settings.focusGestureStrategy) !== null && _e !== void 0 ? _e : CameraSettings.coreDefaults.Camera.Settings.focusGestureStrategy,
-            shouldPreferSmoothAutoFocus: (_f = settings === null || settings === void 0 ? void 0 : settings.shouldPreferSmoothAutoFocus) !== null && _f !== void 0 ? _f : CameraSettings.coreDefaults.Camera.Settings.shouldPreferSmoothAutoFocus,
+            range: (_g = settings === null || settings === void 0 ? void 0 : settings.focusRange) !== null && _g !== void 0 ? _g : CameraSettings.coreDefaults.Camera.Settings.focusRange,
+            focusGestureStrategy: (_h = settings === null || settings === void 0 ? void 0 : settings.focusGestureStrategy) !== null && _h !== void 0 ? _h : CameraSettings.coreDefaults.Camera.Settings.focusGestureStrategy,
+            shouldPreferSmoothAutoFocus: (_j = settings === null || settings === void 0 ? void 0 : settings.shouldPreferSmoothAutoFocus) !== null && _j !== void 0 ? _j : CameraSettings.coreDefaults.Camera.Settings.shouldPreferSmoothAutoFocus,
+            manualLensPosition: (_k = settings === null || settings === void 0 ? void 0 : settings.focus) === null || _k === void 0 ? void 0 : _k.manualLensPosition,
+            focusStrategy: (_l = settings === null || settings === void 0 ? void 0 : settings.focus) === null || _l === void 0 ? void 0 : _l.focusStrategy,
         };
         if (settings !== undefined && settings !== null) {
             Object.getOwnPropertyNames(settings).forEach(propertyName => {
@@ -3665,10 +4436,26 @@ class CameraSettings extends DefaultSerializeable {
         return this[name];
     }
 }
+__decorate([
+    nameForSerialization('torchLevel')
+], CameraSettings.prototype, "torchLevel", void 0);
+__decorate([
+    nameForSerialization('macroMode')
+], CameraSettings.prototype, "macroMode", void 0);
+__decorate([
+    nameForSerialization('adaptiveExposure')
+], CameraSettings.prototype, "adaptiveExposure", void 0);
 __decorate([
     ignoreFromSerialization
 ], CameraSettings.prototype, "focusHiddenProperties", void 0);
 
+var MacroMode;
+(function (MacroMode) {
+    MacroMode["Auto"] = "auto";
+    MacroMode["Off"] = "off";
+    MacroMode["On"] = "on";
+})(MacroMode || (MacroMode = {}));
+
 const NoViewfinder = { type: 'none' };
 
 class RectangularViewfinderAnimation extends DefaultSerializeable {
@@ -3833,6 +4620,7 @@ class LaserlineViewfinder extends DefaultSerializeable {
 }
 
 function parseDefaults(jsonDefaults) {
+    var _a, _b, _c, _d, _e;
     const coreDefaults = {
         Camera: {
             Settings: {
@@ -3842,6 +4630,11 @@ function parseDefaults(jsonDefaults) {
                 zoomGestureZoomFactor: jsonDefaults.Camera.Settings.zoomGestureZoomFactor,
                 focusGestureStrategy: jsonDefaults.Camera.Settings.focusGestureStrategy,
                 shouldPreferSmoothAutoFocus: jsonDefaults.Camera.Settings.shouldPreferSmoothAutoFocus,
+                torchLevel: (_a = jsonDefaults.Camera.Settings.torchLevel) !== null && _a !== void 0 ? _a : 1.0,
+                macroMode: ((_b = jsonDefaults.Camera.Settings.macroMode) !== null && _b !== void 0 ? _b : 'auto'),
+                adaptiveExposure: (_c = jsonDefaults.Camera.Settings.adaptiveExposure) !== null && _c !== void 0 ? _c : false,
+                manualLensPosition: (_d = jsonDefaults.Camera.Settings.manualLensPosition) !== null && _d !== void 0 ? _d : 0,
+                focusStrategy: (_e = jsonDefaults.Camera.Settings.focusStrategy) !== null && _e !== void 0 ? _e : 'auto',
                 properties: jsonDefaults.Camera.Settings.properties,
             },
             defaultPosition: (jsonDefaults.Camera.defaultPosition || null),
@@ -3855,6 +4648,7 @@ function parseDefaults(jsonDefaults) {
             focusGesture: PrivateFocusGestureDeserializer['fromJSON'](JSON.parse(jsonDefaults.DataCaptureView.focusGesture)),
             zoomGesture: PrivateZoomGestureDeserializer['fromJSON'](JSON.parse(jsonDefaults.DataCaptureView.zoomGesture)),
             logoStyle: jsonDefaults.DataCaptureView.logoStyle,
+            shouldShowZoomNotification: jsonDefaults.DataCaptureView.shouldShowZoomNotification,
         },
         RectangularViewfinder: Object
             .keys(jsonDefaults.RectangularViewfinder.styles)
@@ -4298,5 +5092,13 @@ function generateIdentifier() {
     });
 }
 
-export { AimerViewfinder, Anchor, BaseController, BaseDataCaptureView, Brush, CORE_PROXY_TYPE_NAMES, Camera, CameraController, CameraOwnershipHelper, CameraOwnershipManager, CameraPosition, CameraSettings, Color, ContextStatus, ControlImage, CoreProxyAdapter, DataCaptureContext, DataCaptureContextEvents, DataCaptureContextSettings, DataCaptureViewController, DataCaptureViewEvents, DefaultSerializeable, Direction, EventDataParser, EventEmitter, Expiration, FactoryMaker, Feedback, FocusGestureStrategy, FocusRange, FontFamily, FrameDataController, FrameDataSettings, FrameDataSettingsBuilder, FrameSourceListenerEvents, FrameSourceState, HTMLElementState, HtmlElementPosition, HtmlElementSize, ImageBuffer, ImageFrameSource, LaserlineViewfinder, LicenseInfo, LogoStyle, MarginsWithUnit, MeasureUnit, NativeProxy, NoViewfinder, NoneLocationSelection, NumberWithUnit, Observable, OpenSourceSoftwareLicenseInfo, Orientation, Point, PointWithUnit, PrivateFocusGestureDeserializer, PrivateFrameData, PrivateZoomGestureDeserializer, Quadrilateral, RadiusLocationSelection, Rect, RectWithUnit, RectangularLocationSelection, RectangularViewfinder, RectangularViewfinderAnimation, RectangularViewfinderLineStyle, RectangularViewfinderStyle, ScanIntention, ScanditIcon, ScanditIconBuilder, ScanditIconShape, ScanditIconType, Size, SizeWithAspect, SizeWithUnit, SizeWithUnitAndAspect, SizingMode, Sound, SwipeToZoom, TapToFocus, TextAlignment, TorchState, TorchSwitchControl, Vibration, VibrationType, VideoResolution, WaveFormVibration, ZoomSwitchControl, createNativeProxy, ensureCoreDefaults, generateIdentifier, getCoreDefaults, ignoreFromSerialization, ignoreFromSerializationIfNull, loadCoreDefaults, nameForSerialization, registerCoreProxies, registerProxies, serializationDefault, setCoreDefaultsLoader };
+var ClusteringMode;
+(function (ClusteringMode) {
+    ClusteringMode["Disabled"] = "disabled";
+    ClusteringMode["Manual"] = "manual";
+    ClusteringMode["Auto"] = "auto";
+    ClusteringMode["AutoWithManualCorrection"] = "autoWithManualCorrection";
+})(ClusteringMode || (ClusteringMode = {}));
+
+export { AimerViewfinder, Anchor, BaseController, BaseDataCaptureView, Brush, CORE_PROXY_TYPE_NAMES, Camera, CameraController, CameraOwnershipHelper, CameraOwnershipManager, CameraPosition, CameraSettings, ClusteringMode, Color, ContextStatus, ControlImage, CoreProxyAdapter, DataCaptureContext, DataCaptureContextEvents, DataCaptureContextSettings, DataCaptureViewController, DataCaptureViewEvents, DefaultSerializeable, Direction, EventDataParser, EventEmitter, Expiration, FactoryMaker, Feedback, FocusGestureListenerEvents, FocusGestureStrategy, FocusRange, FontFamily, FrameDataController, FrameDataSettings, FrameDataSettingsBuilder, FrameSourceListenerEvents, FrameSourceState, HTMLElementState, HtmlElementPosition, HtmlElementSize, ImageBuffer, ImageFrameSource, LaserlineViewfinder, LicenseInfo, LogoStyle, MacroMode, MacroModeListenerEvents, MarginsWithUnit, MeasureUnit, NativeProxy, NoViewfinder, NoneLocationSelection, NumberWithUnit, Observable, OpenSourceSoftwareLicenseInfo, Orientation, Point, PointWithUnit, PrivateFocusGestureDeserializer, PrivateFrameData, PrivateZoomGestureDeserializer, Quadrilateral, RadiusLocationSelection, Rect, RectWithUnit, RectangularLocationSelection, RectangularViewfinder, RectangularViewfinderAnimation, RectangularViewfinderLineStyle, RectangularViewfinderStyle, SKIP, ScanIntention, ScanditIcon, ScanditIconBuilder, ScanditIconShape, ScanditIconType, Size, SizeWithAspect, SizeWithUnit, SizeWithUnitAndAspect, SizingMode, Sound, SwipeToZoom, TapToFocus, TextAlignment, TorchListenerEvents, TorchState, TorchSwitchControl, Vibration, VibrationType, VideoResolution, WaveFormVibration, ZoomGestureListenerEvents, ZoomSwitchControl, createNativeProxy, ensureCoreDefaults, generateIdentifier, getCoreDefaults, ignoreFromSerialization, ignoreFromSerializationIfNull, loadCoreDefaults, nameForSerialization, registerCoreProxies, registerProxies, serializationDefault, setCoreDefaultsLoader };
 //# sourceMappingURL=index.js.map