@amazon-devices/kepler-a11y-settings-interface-turbo 1.0.0-rn-83

package/dist/src/KeplerA11ySettingsInterface.js

@@ -0,0 +1,836 @@
+"use strict";
+/**
+ * Copyright (c) 2025 - 2026 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ *
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_native_1 = require("react-native");
+const KeplerA11ySettingsInterfaceTurbo_1 = __importDefault(require("./turbo-modules/KeplerA11ySettingsInterfaceTurbo"));
+const dipUtils_1 = require("./utils/dipUtils");
+const constants_1 = require("./utils/constants");
+class KeplerA11ySettingsInterface {
+    __eventEmitter;
+    __uiScaleSettingListener = null;
+    __screenReaderStateListener = null;
+    __screenMagnifierStateListener = null;
+    __textBannerStateListener = null;
+    __colorInversionStateListener = null;
+    __colorCorrectionModeListener = null;
+    __highContrastTextStateListener = null;
+    __audioDescriptionStateListener = null;
+    __timeToTakeActionListener = null;
+    __closedCaptioningStateListener = null;
+    __captioningPreferencesListener = null;
+    constructor() {
+        this.__eventEmitter = new react_native_1.NativeEventEmitter();
+    }
+    /**
+     * Adds a listener for UI scale setting changes.
+     * If a listener is already registered, it will be removed and replaced with the new one.
+     * @param handler Callback function invoked on the main thread when UI scale setting changes
+     * @returns Promise that resolves to boolean representing if listener registered successfully.
+     */
+    async addUiScaleSettingListener(handler) {
+        if (this.__uiScaleSettingListener) {
+            this.__uiScaleSettingListener.remove();
+        }
+        try {
+            const success = await KeplerA11ySettingsInterfaceTurbo_1.default.addUiScaleSettingListener();
+            if (!success) {
+                console.warn('Failed to add UI scale setting listener');
+                return false;
+            }
+            this.__uiScaleSettingListener = this.__eventEmitter.addListener(constants_1.UI_SCALE_SETTING_CHANGED_EVENT, (args) => {
+                handler(args.intValue);
+            });
+            return true;
+        }
+        catch (error) {
+            console.error('[KeplerA11ySettingsInterface] addUiScaleSettingListener error:', error);
+            return false;
+        }
+    }
+    /**
+     * Removes the UI scale setting listener.
+     * @returns Promise that resolves when the listener has been removed.
+     */
+    async removeUiScaleSettingListener() {
+        if (this.__uiScaleSettingListener) {
+            this.__uiScaleSettingListener.remove();
+            this.__uiScaleSettingListener = null;
+        }
+        try {
+            await KeplerA11ySettingsInterfaceTurbo_1.default.removeUiScaleSettingListener();
+        }
+        catch (error) {
+            console.error('[KeplerA11ySettingsInterface] removeUiScaleSettingListener error:', error);
+        }
+    }
+    /**
+     * Adds a listener for screen reader state changes.
+     * If a listener is already registered, it will be removed and replaced with the new one.
+     * @param handler Callback function invoked on the main thread when screen reader state changes
+     * @returns Promise that resolves to boolean representing if listener registered successfully.
+     */
+    async addScreenReaderStateListener(handler) {
+        if (this.__screenReaderStateListener) {
+            this.__screenReaderStateListener.remove();
+        }
+        try {
+            const success = await KeplerA11ySettingsInterfaceTurbo_1.default.addScreenReaderStateListener();
+            if (!success) {
+                console.warn('Failed to add screen reader state listener');
+                return false;
+            }
+            this.__screenReaderStateListener = this.__eventEmitter.addListener(constants_1.SCREEN_READER_STATE_CHANGED_EVENT, (args) => {
+                handler(args.enabled);
+            });
+            return true;
+        }
+        catch (error) {
+            console.error('[KeplerA11ySettingsInterface] addScreenReaderStateListener error:', error);
+            return false;
+        }
+    }
+    /**
+     * Removes the screen reader state listener.
+     * @returns Promise that resolves when the listener has been removed.
+     */
+    async removeScreenReaderStateListener() {
+        if (this.__screenReaderStateListener) {
+            this.__screenReaderStateListener.remove();
+            this.__screenReaderStateListener = null;
+        }
+        try {
+            await KeplerA11ySettingsInterfaceTurbo_1.default.removeScreenReaderStateListener();
+        }
+        catch (error) {
+            console.error('[KeplerA11ySettingsInterface] removeScreenReaderStateListener error:', error);
+        }
+    }
+    /**
+     * Adds a listener for screen magnifier state changes.
+     * If a listener is already registered, it will be removed and replaced with the new one.
+     * @param handler Callback function invoked on the main thread when screen magnifier state changes
+     * @returns Promise that resolves to boolean representing if listener registered successfully.
+     */
+    async addScreenMagnifierStateListener(handler) {
+        if (this.__screenMagnifierStateListener) {
+            this.__screenMagnifierStateListener.remove();
+        }
+        try {
+            const success = await KeplerA11ySettingsInterfaceTurbo_1.default.addScreenMagnifierStateListener();
+            if (!success) {
+                console.warn('Failed to add screen magnifier state listener');
+                return false;
+            }
+            this.__screenMagnifierStateListener = this.__eventEmitter.addListener(constants_1.SCREEN_MAGNIFIER_STATE_CHANGED_EVENT, (args) => {
+                handler(args.enabled);
+            });
+            return true;
+        }
+        catch (error) {
+            console.error('[KeplerA11ySettingsInterface] addScreenMagnifierStateListener error:', error);
+            return false;
+        }
+    }
+    /**
+     * Removes the screen magnifier state listener.
+     * @returns Promise that resolves when the listener has been removed.
+     */
+    async removeScreenMagnifierStateListener() {
+        if (this.__screenMagnifierStateListener) {
+            this.__screenMagnifierStateListener.remove();
+            this.__screenMagnifierStateListener = null;
+        }
+        try {
+            await KeplerA11ySettingsInterfaceTurbo_1.default.removeScreenMagnifierStateListener();
+        }
+        catch (error) {
+            console.error('[KeplerA11ySettingsInterface] removeScreenMagnifierStateListener error:', error);
+        }
+    }
+    /**
+     * Adds a listener for text banner state changes.
+     * If a listener is already registered, it will be removed and replaced with the new one.
+     * @param handler Callback function invoked on the main thread when text banner state changes
+     * @returns Promise that resolves to boolean representing if listener registered successfully.
+     */
+    async addTextBannerStateListener(handler) {
+        if (this.__textBannerStateListener) {
+            this.__textBannerStateListener.remove();
+        }
+        try {
+            const success = await KeplerA11ySettingsInterfaceTurbo_1.default.addTextBannerStateListener();
+            if (!success) {
+                console.warn('Failed to add text banner state listener');
+                return false;
+            }
+            this.__textBannerStateListener = this.__eventEmitter.addListener(constants_1.TEXT_BANNER_STATE_CHANGED_EVENT, (args) => {
+                handler(args.enabled);
+            });
+            return true;
+        }
+        catch (error) {
+            console.error('[KeplerA11ySettingsInterface] addTextBannerStateListener error:', error);
+            return false;
+        }
+    }
+    /**
+     * Removes the text banner state listener.
+     * @returns Promise that resolves when the listener has been removed.
+     */
+    async removeTextBannerStateListener() {
+        if (this.__textBannerStateListener) {
+            this.__textBannerStateListener.remove();
+            this.__textBannerStateListener = null;
+        }
+        try {
+            await KeplerA11ySettingsInterfaceTurbo_1.default.removeTextBannerStateListener();
+        }
+        catch (error) {
+            console.error('[KeplerA11ySettingsInterface] removeTextBannerStateListener error:', error);
+        }
+    }
+    /**
+     * Adds a listener for color inversion state changes.
+     * If a listener is already registered, it will be removed and replaced with the new one.
+     * @param handler Callback function invoked on the main thread when color inversion state changes
+     * @returns Promise that resolves to boolean representing if listener registered successfully.
+     */
+    async addColorInversionStateListener(handler) {
+        if (this.__colorInversionStateListener) {
+            this.__colorInversionStateListener.remove();
+        }
+        try {
+            const success = await KeplerA11ySettingsInterfaceTurbo_1.default.addColorInversionStateListener();
+            if (!success) {
+                console.warn('Failed to add color inversion state listener');
+                return false;
+            }
+            this.__colorInversionStateListener = this.__eventEmitter.addListener(constants_1.COLOR_INVERSION_STATE_CHANGED_EVENT, (args) => {
+                handler(args.enabled);
+            });
+            return true;
+        }
+        catch (error) {
+            console.error('[KeplerA11ySettingsInterface] addColorInversionStateListener error:', error);
+            return false;
+        }
+    }
+    /**
+     * Removes the color inversion state listener.
+     * @returns Promise that resolves when the listener has been removed.
+     */
+    async removeColorInversionStateListener() {
+        if (this.__colorInversionStateListener) {
+            this.__colorInversionStateListener.remove();
+            this.__colorInversionStateListener = null;
+        }
+        try {
+            await KeplerA11ySettingsInterfaceTurbo_1.default.removeColorInversionStateListener();
+        }
+        catch (error) {
+            console.error('[KeplerA11ySettingsInterface] removeColorInversionStateListener error:', error);
+        }
+    }
+    /**
+     * Adds a listener for color correction mode changes.
+     * If a listener is already registered, it will be removed and replaced with the new one.
+     * @param handler Callback function invoked on the main thread when color correction mode changes
+     * @returns Promise that resolves to boolean representing if listener registered successfully.
+     */
+    async addColorCorrectionModeListener(handler) {
+        if (this.__colorCorrectionModeListener) {
+            this.__colorCorrectionModeListener.remove();
+        }
+        try {
+            const success = await KeplerA11ySettingsInterfaceTurbo_1.default.addColorCorrectionModeListener();
+            if (!success) {
+                console.warn('Failed to add color correction mode listener');
+                return false;
+            }
+            this.__colorCorrectionModeListener = this.__eventEmitter.addListener(constants_1.COLOR_CORRECTION_MODE_CHANGED_EVENT, (args) => {
+                handler(args.mode);
+            });
+            return true;
+        }
+        catch (error) {
+            console.error('[KeplerA11ySettingsInterface] addColorCorrectionModeListener error:', error);
+            return false;
+        }
+    }
+    /**
+     * Removes the color correction mode listener.
+     * @returns Promise that resolves when the listener has been removed.
+     */
+    async removeColorCorrectionModeListener() {
+        if (this.__colorCorrectionModeListener) {
+            this.__colorCorrectionModeListener.remove();
+            this.__colorCorrectionModeListener = null;
+        }
+        try {
+            await KeplerA11ySettingsInterfaceTurbo_1.default.removeColorCorrectionModeListener();
+        }
+        catch (error) {
+            console.error('[KeplerA11ySettingsInterface] removeColorCorrectionModeListener error:', error);
+        }
+    }
+    /**
+     * Adds a listener for high contrast text state changes.
+     * If a listener is already registered, it will be removed and replaced with the new one.
+     * @param handler Callback function invoked on the main thread when high contrast text state changes
+     * @returns Promise that resolves to boolean representing if listener registered successfully.
+     */
+    async addHighContrastTextStateListener(handler) {
+        if (this.__highContrastTextStateListener) {
+            this.__highContrastTextStateListener.remove();
+        }
+        try {
+            const success = await KeplerA11ySettingsInterfaceTurbo_1.default.addHighContrastTextStateListener();
+            if (!success) {
+                console.warn('Failed to add high contrast text state listener');
+                return false;
+            }
+            this.__highContrastTextStateListener = this.__eventEmitter.addListener(constants_1.HIGH_CONTRAST_TEXT_STATE_CHANGED_EVENT, (args) => {
+                handler(args.enabled);
+            });
+            return true;
+        }
+        catch (error) {
+            console.error('[KeplerA11ySettingsInterface] addHighContrastTextStateListener error:', error);
+            return false;
+        }
+    }
+    /**
+     * Removes the high contrast text state listener.
+     * @returns Promise that resolves when the listener has been removed.
+     */
+    async removeHighContrastTextStateListener() {
+        if (this.__highContrastTextStateListener) {
+            this.__highContrastTextStateListener.remove();
+            this.__highContrastTextStateListener = null;
+        }
+        try {
+            await KeplerA11ySettingsInterfaceTurbo_1.default.removeHighContrastTextStateListener();
+        }
+        catch (error) {
+            console.error('[KeplerA11ySettingsInterface] removeHighContrastTextStateListener error:', error);
+        }
+    }
+    /**
+     * Adds a listener for audio description state changes.
+     * If a listener is already registered, it will be removed and replaced with the new one.
+     * @param handler Callback function invoked on the main thread when audio description state changes
+     * @returns Promise that resolves to boolean representing if listener registered successfully.
+     */
+    async addAudioDescriptionStateListener(handler) {
+        if (this.__audioDescriptionStateListener) {
+            this.__audioDescriptionStateListener.remove();
+        }
+        try {
+            const success = await KeplerA11ySettingsInterfaceTurbo_1.default.addAudioDescriptionStateListener();
+            if (!success) {
+                console.warn('Failed to add audio description state listener');
+                return false;
+            }
+            this.__audioDescriptionStateListener = this.__eventEmitter.addListener(constants_1.AUDIO_DESCRIPTION_STATE_CHANGED_EVENT, (args) => {
+                handler(args.enabled);
+            });
+            return true;
+        }
+        catch (error) {
+            console.error('[KeplerA11ySettingsInterface] addAudioDescriptionStateListener error:', error);
+            return false;
+        }
+    }
+    /**
+     * Removes the audio description state listener.
+     * @returns Promise that resolves when the listener has been removed.
+     */
+    async removeAudioDescriptionStateListener() {
+        if (this.__audioDescriptionStateListener) {
+            this.__audioDescriptionStateListener.remove();
+            this.__audioDescriptionStateListener = null;
+        }
+        try {
+            await KeplerA11ySettingsInterfaceTurbo_1.default.removeAudioDescriptionStateListener();
+        }
+        catch (error) {
+            console.error('[KeplerA11ySettingsInterface] removeAudioDescriptionStateListener error:', error);
+        }
+    }
+    /**
+     * Adds a listener for time to take action changes.
+     * If a listener is already registered, it will be removed and replaced with the new one.
+     * @param handler Callback function invoked on the main thread when time to take action changes
+     * @returns Promise that resolves to boolean representing if listener registered successfully.
+     */
+    async addTimeToTakeActionListener(handler) {
+        if (this.__timeToTakeActionListener) {
+            this.__timeToTakeActionListener.remove();
+        }
+        try {
+            const success = await KeplerA11ySettingsInterfaceTurbo_1.default.addTimeToTakeActionListener();
+            if (!success) {
+                console.warn('Failed to add time to take action listener');
+                return false;
+            }
+            this.__timeToTakeActionListener = this.__eventEmitter.addListener(constants_1.TIME_TO_TAKE_ACTION_CHANGED_EVENT, (args) => {
+                handler(args.value);
+            });
+            return true;
+        }
+        catch (error) {
+            console.error('[KeplerA11ySettingsInterface] addTimeToTakeActionListener error:', error);
+            return false;
+        }
+    }
+    /**
+     * Removes the time to take action listener.
+     * @returns Promise that resolves when the listener has been removed.
+     */
+    async removeTimeToTakeActionListener() {
+        if (this.__timeToTakeActionListener) {
+            this.__timeToTakeActionListener.remove();
+            this.__timeToTakeActionListener = null;
+        }
+        try {
+            await KeplerA11ySettingsInterfaceTurbo_1.default.removeTimeToTakeActionListener();
+        }
+        catch (error) {
+            console.error('[KeplerA11ySettingsInterface] removeTimeToTakeActionListener error:', error);
+        }
+    }
+    /**
+     * Adds a listener for closed captioning state changes.
+     * If a listener is already registered, it will be removed and replaced with the new one.
+     * @param handler Callback function invoked on the main thread when closed captioning state changes
+     * @returns Promise that resolves to boolean representing if listener registered successfully.
+     */
+    async addClosedCaptioningStateListener(handler) {
+        if (this.__closedCaptioningStateListener) {
+            this.__closedCaptioningStateListener.remove();
+        }
+        try {
+            const success = await KeplerA11ySettingsInterfaceTurbo_1.default.addClosedCaptioningStateListener();
+            if (!success) {
+                console.warn('Failed to add closed captioning state listener');
+                return false;
+            }
+            this.__closedCaptioningStateListener = this.__eventEmitter.addListener(constants_1.CLOSED_CAPTIONING_STATE_CHANGED_EVENT, (args) => {
+                handler(args.enabled);
+            });
+            return true;
+        }
+        catch (error) {
+            console.error('[KeplerA11ySettingsInterface] addClosedCaptioningStateListener error:', error);
+            return false;
+        }
+    }
+    /**
+     * Removes the closed captioning state listener.
+     * @returns Promise that resolves when the listener has been removed.
+     */
+    async removeClosedCaptioningStateListener() {
+        if (this.__closedCaptioningStateListener) {
+            this.__closedCaptioningStateListener.remove();
+            this.__closedCaptioningStateListener = null;
+        }
+        try {
+            await KeplerA11ySettingsInterfaceTurbo_1.default.removeClosedCaptioningStateListener();
+        }
+        catch (error) {
+            console.error('[KeplerA11ySettingsInterface] removeClosedCaptioningStateListener error:', error);
+        }
+    }
+    /**
+     * Adds a listener for captioning preferences changes.
+     * If a listener is already registered, it will be removed and replaced with the new one.
+     * @param handler Callback function invoked on the main thread when captioning preferences change
+     * @returns Promise that resolves to boolean representing if listener registered successfully.
+     */
+    async addCaptioningPreferencesListener(handler) {
+        if (this.__captioningPreferencesListener) {
+            this.__captioningPreferencesListener.remove();
+        }
+        try {
+            const success = await KeplerA11ySettingsInterfaceTurbo_1.default.addCaptioningPreferencesListener();
+            if (!success) {
+                console.warn('Failed to add captioning preferences listener');
+                return false;
+            }
+            this.__captioningPreferencesListener = this.__eventEmitter.addListener(constants_1.CAPTIONING_PREFERENCES_CHANGED_EVENT, (args) => {
+                handler(args);
+            });
+            return true;
+        }
+        catch (error) {
+            console.error('[KeplerA11ySettingsInterface] addCaptioningPreferencesListener error:', error);
+            return false;
+        }
+    }
+    /**
+     * Removes the captioning preferences listener.
+     * @returns Promise that resolves when the listener has been removed.
+     */
+    async removeCaptioningPreferencesListener() {
+        if (this.__captioningPreferencesListener) {
+            this.__captioningPreferencesListener.remove();
+            this.__captioningPreferencesListener = null;
+        }
+        try {
+            await KeplerA11ySettingsInterfaceTurbo_1.default.removeCaptioningPreferencesListener();
+        }
+        catch (error) {
+            console.error('[KeplerA11ySettingsInterface] removeCaptioningPreferencesListener error:', error);
+        }
+    }
+    /**
+     * Gets the scaling multiplier for the given original size and scaling properties.
+     *
+     * This method should be used to retrieve a scale factor, which can be applied to related
+     * values that do not have the same scaling properties, like the height and width of an image.
+     *
+     * Note: Prefer using the useScalingMultiplier hook from UiScaleSettingContextProvider.
+     *
+     * @param originalSize The original size to scale (in DIP if PLATFORM_DENSITY_INDEPENDENT_PIXEL
+     *   is enabled, or in physical pixels otherwise)
+     * @param scalingProps Properties that define how scaling should be applied
+     * @returns Promise that resolves to the scaling multiplier
+     */
+    async getScalingMultiplier(originalSize, scalingProps) {
+        try {
+            const dipFactor = (0, dipUtils_1.getDipConversionFactor)();
+            const result = await KeplerA11ySettingsInterfaceTurbo_1.default.getScalingMultiplier(originalSize / dipFactor, (0, dipUtils_1.convertScalingPropsToDip)(scalingProps, dipFactor));
+            return result;
+        }
+        catch (error) {
+            console.error('[KeplerA11ySettingsInterface] getScalingMultiplier error:', error);
+            return 1.0;
+        }
+    }
+    /**
+     * Gets the scaled size for the given original size and scaling properties.
+     *
+     * Note: Prefer using the useScaledSize hook from UiScaleSettingContextProvider.
+     *
+     * @param originalSize The original size to scale (in DIP if PLATFORM_DENSITY_INDEPENDENT_PIXEL
+     *   is enabled, or in physical pixels otherwise)
+     * @param scalingProps Properties that define how scaling should be applied
+     * @returns Promise that resolves to the scaled size
+     */
+    async getScaledSize(originalSize, scalingProps) {
+        try {
+            const dipFactor = (0, dipUtils_1.getDipConversionFactor)();
+            let result = await KeplerA11ySettingsInterfaceTurbo_1.default.getScaledSize(originalSize / dipFactor, (0, dipUtils_1.convertScalingPropsToDip)(scalingProps, dipFactor)) * dipFactor;
+            if (scalingProps.maxSize != null)
+                result = Math.min(result, scalingProps.maxSize);
+            if (scalingProps.minSize != null)
+                result = Math.max(result, scalingProps.minSize);
+            return result;
+        }
+        catch (error) {
+            console.error('[KeplerA11ySettingsInterface] getScaledSize error:', error);
+            return originalSize;
+        }
+    }
+    /**
+     * Gets the current UI scale setting.
+     *
+     * Note: Prefer using the useUiScaleSetting hook from UiScaleSettingContextProvider.
+     *
+     * @returns Promise that resolves to the current UI scale setting
+     */
+    async getUiScaleSetting() {
+        try {
+            return await KeplerA11ySettingsInterfaceTurbo_1.default.getUiScaleSetting();
+        }
+        catch (error) {
+            console.error('[KeplerA11ySettingsInterface] getUiScaleSetting error:', error);
+            return 1;
+        }
+    }
+    /**
+     * Checks if screen reader is enabled.
+     * @returns Promise that resolves to true if screen reader is enabled, false otherwise
+     */
+    async isScreenReaderEnabled() {
+        try {
+            return await KeplerA11ySettingsInterfaceTurbo_1.default.isScreenReaderEnabled();
+        }
+        catch (error) {
+            console.error('[KeplerA11ySettingsInterface] isScreenReaderEnabled error:', error);
+            return false;
+        }
+    }
+    /**
+     * Checks if screen magnifier is enabled.
+     * @returns Promise that resolves to true if screen magnifier is enabled, false otherwise
+     */
+    async isScreenMagnifierEnabled() {
+        try {
+            return await KeplerA11ySettingsInterfaceTurbo_1.default.isScreenMagnifierEnabled();
+        }
+        catch (error) {
+            console.error('[KeplerA11ySettingsInterface] isScreenMagnifierEnabled error:', error);
+            return false;
+        }
+    }
+    /**
+     * Checks if text banner is enabled.
+     * @returns Promise that resolves to true if text banner is enabled, false otherwise
+     */
+    async isTextBannerEnabled() {
+        try {
+            return await KeplerA11ySettingsInterfaceTurbo_1.default.isTextBannerEnabled();
+        }
+        catch (error) {
+            console.error('[KeplerA11ySettingsInterface] isTextBannerEnabled error:', error);
+            return false;
+        }
+    }
+    /**
+     * Checks if color inversion is enabled.
+     * @returns Promise that resolves to true if color inversion is enabled, false otherwise
+     */
+    async isColorInversionEnabled() {
+        try {
+            return await KeplerA11ySettingsInterfaceTurbo_1.default.isColorInversionEnabled();
+        }
+        catch (error) {
+            console.error('[KeplerA11ySettingsInterface] isColorInversionEnabled error:', error);
+            return false;
+        }
+    }
+    /**
+     * Gets the current color correction mode.
+     * @returns Promise that resolves to the current color correction mode
+     */
+    async getColorCorrectionMode() {
+        try {
+            return await KeplerA11ySettingsInterfaceTurbo_1.default.getColorCorrectionMode();
+        }
+        catch (error) {
+            console.error('[KeplerA11ySettingsInterface] getColorCorrectionMode error:', error);
+            return 'off';
+        }
+    }
+    /**
+     * Checks if high contrast text is enabled.
+     * @returns Promise that resolves to true if high contrast text is enabled, false otherwise
+     */
+    async isHighContrastTextEnabled() {
+        try {
+            return await KeplerA11ySettingsInterfaceTurbo_1.default.isHighContrastTextEnabled();
+        }
+        catch (error) {
+            console.error('[KeplerA11ySettingsInterface] isHighContrastTextEnabled error:', error);
+            return false;
+        }
+    }
+    /**
+     * Checks if audio description is preferred.
+     * @returns Promise that resolves to true if audio description is preferred, false otherwise
+     */
+    async isAudioDescriptionPreferred() {
+        try {
+            return await KeplerA11ySettingsInterfaceTurbo_1.default.isAudioDescriptionPreferred();
+        }
+        catch (error) {
+            console.error('[KeplerA11ySettingsInterface] isAudioDescriptionPreferred error:', error);
+            return false;
+        }
+    }
+    /**
+     * Gets the current time to take action setting.
+     * @returns Promise that resolves to the current timeout multiplier
+     */
+    async getTimeToTakeAction() {
+        try {
+            return await KeplerA11ySettingsInterfaceTurbo_1.default.getTimeToTakeAction();
+        }
+        catch (error) {
+            console.error('[KeplerA11ySettingsInterface] getTimeToTakeAction error:', error);
+            return 'default';
+        }
+    }
+    /**
+     * Checks if closed captioning is enabled.
+     * @returns Promise that resolves to true if closed captioning is enabled, false otherwise
+     */
+    async isClosedCaptioningEnabled() {
+        try {
+            return await KeplerA11ySettingsInterfaceTurbo_1.default.isClosedCaptioningEnabled();
+        }
+        catch (error) {
+            console.error('[KeplerA11ySettingsInterface] isClosedCaptioningEnabled error:', error);
+            return false;
+        }
+    }
+    /**
+     * Gets all captioning preferences.
+     * @returns Promise that resolves to object containing all captioning preference settings
+     */
+    async getCaptionPreferences() {
+        try {
+            return await KeplerA11ySettingsInterfaceTurbo_1.default.getCaptionPreferences();
+        }
+        catch (error) {
+            console.error('[KeplerA11ySettingsInterface] getCaptionPreferences error:', error);
+            return {};
+        }
+    }
+    /**
+     * Sets the screen reader enabled state.
+     * Requires com.amazon.devconf.privilege.accessibility.write permission.
+     * @param enabled true to enable screen reader, false to disable
+     */
+    async setScreenReaderEnabled(enabled) {
+        try {
+            await KeplerA11ySettingsInterfaceTurbo_1.default.setScreenReaderEnabled(enabled);
+        }
+        catch (error) {
+            console.error('[KeplerA11ySettingsInterface] setScreenReaderEnabled error:', error);
+        }
+    }
+    /**
+     * Sets the screen magnifier enabled state.
+     * Requires com.amazon.devconf.privilege.accessibility.write permission.
+     * @param enabled true to enable screen magnifier, false to disable
+     */
+    async setScreenMagnifierEnabled(enabled) {
+        try {
+            await KeplerA11ySettingsInterfaceTurbo_1.default.setScreenMagnifierEnabled(enabled);
+        }
+        catch (error) {
+            console.error('[KeplerA11ySettingsInterface] setScreenMagnifierEnabled error:', error);
+        }
+    }
+    /**
+     * Sets the text banner enabled state.
+     * Requires com.amazon.devconf.privilege.accessibility.write permission.
+     * @param enabled true to enable text banner, false to disable
+     */
+    async setTextBannerEnabled(enabled) {
+        try {
+            await KeplerA11ySettingsInterfaceTurbo_1.default.setTextBannerEnabled(enabled);
+        }
+        catch (error) {
+            console.error('[KeplerA11ySettingsInterface] setTextBannerEnabled error:', error);
+        }
+    }
+    /**
+     * Sets the color inversion enabled state.
+     * Requires com.amazon.devconf.privilege.accessibility.write permission.
+     * @param enabled true to enable color inversion, false to disable
+     */
+    async setColorInversionEnabled(enabled) {
+        try {
+            await KeplerA11ySettingsInterfaceTurbo_1.default.setColorInversionEnabled(enabled);
+        }
+        catch (error) {
+            console.error('[KeplerA11ySettingsInterface] setColorInversionEnabled error:', error);
+        }
+    }
+    /**
+     * Sets the color correction mode.
+     * Requires com.amazon.devconf.privilege.accessibility.write permission.
+     * @param mode The color correction mode to set
+     */
+    async setColorCorrectionMode(mode) {
+        try {
+            await KeplerA11ySettingsInterfaceTurbo_1.default.setColorCorrectionMode(mode);
+        }
+        catch (error) {
+            console.error('[KeplerA11ySettingsInterface] setColorCorrectionMode error:', error);
+        }
+    }
+    /**
+     * Sets the high contrast text enabled state.
+     * Requires com.amazon.devconf.privilege.accessibility.write permission.
+     * @param enabled true to enable high contrast text, false to disable
+     */
+    async setHighContrastTextEnabled(enabled) {
+        try {
+            await KeplerA11ySettingsInterfaceTurbo_1.default.setHighContrastTextEnabled(enabled);
+        }
+        catch (error) {
+            console.error('[KeplerA11ySettingsInterface] setHighContrastTextEnabled error:', error);
+        }
+    }
+    /**
+     * Sets the audio description preference.
+     * Requires com.amazon.devconf.privilege.accessibility.write permission.
+     * @param enabled true to prefer audio description, false otherwise
+     */
+    async setAudioDescriptionPreferred(enabled) {
+        try {
+            await KeplerA11ySettingsInterfaceTurbo_1.default.setAudioDescriptionPreferred(enabled);
+        }
+        catch (error) {
+            console.error('[KeplerA11ySettingsInterface] setAudioDescriptionPreferred error:', error);
+        }
+    }
+    /**
+     * Sets the time to take action multiplier.
+     * Requires com.amazon.devconf.privilege.accessibility.write permission.
+     * @param multiplier The timeout multiplier to set
+     */
+    async setTimeToTakeAction(multiplier) {
+        try {
+            await KeplerA11ySettingsInterfaceTurbo_1.default.setTimeToTakeAction(multiplier);
+        }
+        catch (error) {
+            console.error('[KeplerA11ySettingsInterface] setTimeToTakeAction error:', error);
+        }
+    }
+    /**
+     * Sets the UI scale setting.
+     * Requires com.amazon.devconf.privilege.accessibility.write permission.
+     * @param setting The UI scale setting to set
+     */
+    async setUiScaleSetting(setting) {
+        try {
+            await KeplerA11ySettingsInterfaceTurbo_1.default.setUiScaleSetting(setting);
+        }
+        catch (error) {
+            console.error('[KeplerA11ySettingsInterface] setUiScaleSetting error:', error);
+        }
+    }
+    /**
+     * Sets the closed captioning enabled state.
+     * Requires com.amazon.devconf.privilege.accessibility.write permission.
+     * @param enabled true to enable closed captioning, false to disable
+     */
+    async setClosedCaptioningEnabled(enabled) {
+        try {
+            await KeplerA11ySettingsInterfaceTurbo_1.default.setClosedCaptioningEnabled(enabled);
+        }
+        catch (error) {
+            console.error('[KeplerA11ySettingsInterface] setClosedCaptioningEnabled error:', error);
+        }
+    }
+    /**
+     * Sets multiple captioning preferences at once.
+     * Requires com.amazon.devconf.privilege.accessibility.write permission.
+     * @param prefs Object containing captioning preference settings to update.
+     * Only the properties present in the object will be updated.
+     */
+    async setCaptionPreferences(prefs) {
+        try {
+            await KeplerA11ySettingsInterfaceTurbo_1.default.setCaptionPreferences(prefs);
+        }
+        catch (error) {
+            console.error('[KeplerA11ySettingsInterface] setCaptionPreferences error:', error);
+        }
+    }
+}
+exports.default = new KeplerA11ySettingsInterface();