@trezor/connect 9.4.2-beta.1 → 9.4.2

package/lib/data/version.d.ts

@@ -1,4 +1,4 @@
-export declare const VERSION = "9.4.2-beta.1";
+export declare const VERSION = "9.4.2";
 export declare const DEFAULT_DOMAIN: string;
 export declare const CONTENT_SCRIPT_VERSION = 1;
 //# sourceMappingURL=version.d.ts.map

package/lib/data/version.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CONTENT_SCRIPT_VERSION = exports.DEFAULT_DOMAIN = exports.VERSION = void 0;
-exports.VERSION = '9.4.2-beta.1';
+exports.VERSION = '9.4.2';
 const versionN = exports.VERSION.split('.').map(s => parseInt(s, 10));
 const isBeta = exports.VERSION.includes('beta');
 exports.DEFAULT_DOMAIN = isBeta

package/lib/device/Device.d.ts

@@ -1,11 +1,13 @@
 import { Deferred, TypedEmitter } from '@trezor/utils';
+import { Session } from '@trezor/transport';
 import { TransportProtocol } from '@trezor/protocol';
-import { DeviceCommands, PassphrasePromptResponse } from './DeviceCommands';
+import { DeviceCommands } from './DeviceCommands';
 import { PROTO, NETWORK } from '../constants';
-import { DEVICE, DeviceButtonRequestPayload } from '../events';
+import { DEVICE, DeviceButtonRequestPayload, UiResponsePin, UiResponsePassphrase, UiResponseWord } from '../events';
 import { type Transport, type Descriptor } from '@trezor/transport';
 import { Device as DeviceTyped, DeviceFirmwareStatus, DeviceState, Features, ReleaseInfo, UnavailableCapabilities, FirmwareType, VersionArray, KnownDevice } from '../types';
 import { IStateStorage } from './StateStorage';
+import type { PromptCallback } from './prompts';
 export type RunOptions = {
     skipFinalReload?: boolean;
     waiting?: boolean;
@@ -17,9 +19,9 @@ export type RunOptions = {
 export declare const GET_FEATURES_TIMEOUT = 3000;
 export declare const GET_FEATURES_TIMEOUT_REACT_NATIVE = 20000;
 export interface DeviceEvents {
-    [DEVICE.PIN]: (device: Device, b: PROTO.PinMatrixRequestType | undefined, callback: (err: any, pin: string) => void) => void;
-    [DEVICE.WORD]: (device: Device, b: PROTO.WordRequestType, callback: (err: any, word: string) => void) => void;
-    [DEVICE.PASSPHRASE]: (device: Device, callback: (response: PassphrasePromptResponse) => void) => void;
+    [DEVICE.PIN]: (device: Device, type: PROTO.PinMatrixRequestType | undefined, callback: PromptCallback<UiResponsePin['payload']>) => void;
+    [DEVICE.WORD]: (device: Device, type: PROTO.WordRequestType, callback: PromptCallback<UiResponseWord['payload']>) => void;
+    [DEVICE.PASSPHRASE]: (device: Device, callback: PromptCallback<UiResponsePassphrase['payload']>) => void;
     [DEVICE.PASSPHRASE_ON_DEVICE]: () => void;
     [DEVICE.BUTTON]: (device: Device, payload: DeviceButtonRequestPayload) => void;
     [DEVICE.ACQUIRED]: () => void;
@@ -36,9 +38,10 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
     private acquirePromise?;
     private releasePromise?;
     private runPromise?;
-    private transportSession?;
+    transportSession?: Session | null;
     keepTransportSession: boolean;
     commands?: DeviceCommands;
+    private cancelableAction?;
     loaded: boolean;
     inconsistent: boolean;
     firstRunPromise: Deferred<boolean>;
@@ -61,6 +64,8 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
     cleanup(): Promise<void>;
     run(fn?: () => Promise<void>, options?: RunOptions): Promise<void>;
     override(error: Error): Promise<void>;
+    setCancelableAction(callback: NonNullable<typeof this.cancelableAction>): void;
+    clearCancelableAction(): void;
     interruptionFromUser(error: Error): Promise<void>;
     interruptionFromOutside(): void;
     _runInner<X>(fn: (() => Promise<X>) | undefined, options: RunOptions): Promise<void>;
@@ -86,7 +91,7 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
     private _uploadTranslationData;
     private _updateFeatures;
     isUnacquired(): boolean;
-    disconnect(): void;
+    disconnect(): Promise<void>;
     isBootloader(): boolean;
     isInitialized(): boolean;
     isSeedless(): boolean;
@@ -104,6 +109,9 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
     hasUnexpectedMode(allow: string[], require: string[]): "ui-device_bootloader_mode" | "ui-device_not_in_bootloader_mode" | "ui-device_not_initialized" | "ui-device_seedless" | null;
     updateDescriptor(descriptor: Descriptor): void;
     dispose(): Promise<{
+        success: false;
+        error: "session not found";
+    } | {
         success: false;
         error: "Network request failed";
     } | {
@@ -115,9 +123,6 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
     } | {
         success: false;
         error: "unexpected error";
-    } | {
-        success: false;
-        error: "session not found";
     } | {
         success: false;
         error: "Aborted by timeout";
@@ -139,6 +144,5 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
     } | import("@trezor/transport/lib/types").Success<void> | undefined>;
     getMode(): "normal" | "bootloader" | "initialize" | "seedless";
     toMessageObject(): DeviceTyped;
-    legacyForceRelease(): Promise<void>;
 }
 //# sourceMappingURL=Device.d.ts.map

package/lib/device/Device.js

@@ -142,15 +142,27 @@ class Device extends utils_1.TypedEmitter {
             await this.releasePromise;
         }
     }
+    setCancelableAction(callback) {
+        this.cancelableAction = (e) => callback(e)
+            .catch(e => {
+            _log.debug('cancelableAction error', e);
+        })
+            .finally(() => {
+            this.clearCancelableAction();
+        });
+    }
+    clearCancelableAction() {
+        this.cancelableAction = undefined;
+    }
     async interruptionFromUser(error) {
+        var _a, _b;
         _log.debug('interruptionFromUser');
+        await ((_a = this.cancelableAction) === null || _a === void 0 ? void 0 : _a.call(this, error));
+        await ((_b = this.commands) === null || _b === void 0 ? void 0 : _b.cancel());
         if (this.runPromise) {
             this.runPromise.reject(error);
             delete this.runPromise;
         }
-        if (this.commands) {
-            await this.commands.cancel();
-        }
     }
     interruptionFromOutside() {
         _log.debug('interruptionFromOutside');
@@ -448,8 +460,7 @@ class Device extends utils_1.TypedEmitter {
     disconnect() {
         _log.debug('Disconnect cleanup');
         this.transportSession = null;
-        this.interruptionFromUser(constants_1.ERRORS.TypedError('Device_Disconnected'));
-        delete this.runPromise;
+        return this.interruptionFromUser(constants_1.ERRORS.TypedError('Device_Disconnected'));
     }
     isBootloader() {
         return this.features && !!this.features.bootloader_mode;
@@ -529,12 +540,12 @@ class Device extends utils_1.TypedEmitter {
         };
     }
     async dispose() {
+        var _a, _b;
         this.removeAllListeners();
         if (this.isUsedHere() && this.transportSession) {
             try {
-                if (this.commands) {
-                    await this.commands.cancel();
-                }
+                await ((_a = this.cancelableAction) === null || _a === void 0 ? void 0 : _a.call(this));
+                await ((_b = this.commands) === null || _b === void 0 ? void 0 : _b.cancel());
                 return this.transport.release({
                     session: this.transportSession,
                     path: this.originalDescriptor.path,
@@ -598,13 +609,6 @@ class Device extends utils_1.TypedEmitter {
             authenticityChecks: this.authenticityChecks,
         };
     }
-    async legacyForceRelease() {
-        if (this.isUsedHere()) {
-            await this.acquire();
-            await this.getFeatures();
-            await this.release();
-        }
-    }
 }
 exports.Device = Device;
 //# sourceMappingURL=Device.js.map

package/lib/device/DeviceCommands.d.ts

@@ -13,19 +13,12 @@ type TypedCallResponseMap = {
     [K in keyof MessageType]: TypedPayload<K>;
 };
 type DefaultPayloadMessage = TypedCallResponseMap[keyof MessageType];
-export type PassphrasePromptResponse = {
-    passphrase?: string;
-    passphraseOnDevice?: boolean;
-    cache?: boolean;
-};
 export declare class DeviceCommands {
     device: Device;
     transport: Transport;
     transportSession: Session;
     disposed: boolean;
     callPromise?: ReturnType<Transport['call']>;
-    _cancelableRequest?: (error?: any) => void;
-    _cancelableRequestBySend?: boolean;
     constructor(device: Device, transport: Transport, transportSession: Session);
     dispose(): void;
     isDisposed(): boolean;
@@ -78,15 +71,52 @@ export declare class DeviceCommands {
     _commonCall(type: MessageKey, msg?: DefaultPayloadMessage['message']): Promise<DefaultPayloadMessage>;
     _filterCommonTypes(res: DefaultPayloadMessage): Promise<DefaultPayloadMessage>;
     private _getAddress;
-    _promptPin(type?: Messages.PinMatrixRequestType): Promise<string>;
-    _promptPassphrase(): Promise<PassphrasePromptResponse>;
-    _promptWord(type: Messages.WordRequestType): Promise<string>;
     getAccountDescriptor(coinInfo: CoinInfo, indexOrPath: number | number[], derivationType?: Messages.CardanoDerivationType): Promise<{
         descriptor: string;
         legacyXpub?: string;
         address_n: number[];
         descriptorChecksum?: string;
     }>;
+    cancelWithFallback(): Promise<{
+        readonly success: false;
+        readonly error: "session not found";
+    } | import("@trezor/transport/lib/types").Success<import("@trezor/protobuf").MessageFromTrezor> | {
+        success: false;
+        error: "Network request failed";
+    } | {
+        success: false;
+        error: "Wrong result type.";
+    } | {
+        success: false;
+        error: "other call in progress";
+    } | {
+        success: false;
+        error: "Malformed protocol format";
+    } | {
+        success: false;
+        error: "device disconnected during action";
+    } | {
+        success: false;
+        error: "unexpected error";
+    } | {
+        success: false;
+        error: "Aborted by timeout";
+    } | {
+        success: false;
+        error: "Aborted by signal";
+    } | {
+        success: false;
+        error: "This transport can not be used in this environment";
+    } | {
+        success: false;
+        error: "device not found";
+    } | {
+        success: false;
+        error: "Unable to open device";
+    } | {
+        success: false;
+        error: "A transfer error has occurred.";
+    } | import("@trezor/transport/lib/types").Success<undefined> | undefined>;
     cancel(): Promise<void>;
 }
 export type TypedCall = DeviceCommands['typedCall'];

package/lib/device/DeviceCommands.js

@@ -14,6 +14,7 @@ const coinInfo_1 = require("../data/coinInfo");
 const debug_1 = require("../utils/debug");
 const schema_utils_1 = require("@trezor/schema-utils");
 const resolveDescriptorForTaproot_1 = require("./resolveDescriptorForTaproot");
+const prompts_1 = require("./prompts");
 const logger = (0, debug_1.initLog)('DeviceCommands');
 const assertType = (res, resType) => {
     const splitResTypes = Array.isArray(resType) ? resType : resType.split('|');
@@ -45,7 +46,6 @@ class DeviceCommands {
     }
     dispose() {
         this.disposed = true;
-        this._cancelableRequest = undefined;
     }
     isDisposed() {
         return this.disposed;
@@ -243,7 +243,7 @@ class DeviceCommands {
         return this._filterCommonTypes(resp);
     }
     _filterCommonTypes(res) {
-        this._cancelableRequestBySend = false;
+        this.device.clearCancelableAction();
         if (res.type === 'Failure') {
             const { code } = res.message;
             let { message } = res.message;
@@ -259,7 +259,7 @@ class DeviceCommands {
             return Promise.resolve(res);
         }
         if (res.type === 'ButtonRequest') {
-            this._cancelableRequestBySend = true;
+            this.device.setCancelableAction(() => this.cancelWithFallback());
             if (res.message.code === 'ButtonRequest_PassphraseEntry') {
                 this.device.emit(events_1.DEVICE.PASSPHRASE_ON_DEVICE);
             }
@@ -274,25 +274,22 @@ class DeviceCommands {
             });
         }
         if (res.type === 'PinMatrixRequest') {
-            return this._promptPin(res.message.type).then(pin => this._commonCall('PinMatrixAck', { pin }).then(response => {
+            return (0, prompts_1.promptPin)(this.device, res.message.type).then(pin => this._commonCall('PinMatrixAck', { pin }).then(response => {
                 if (!this.device.features.unlocked) {
                     return this.device.getFeatures().then(() => response);
                 }
                 return response;
-            }), () => this._commonCall('Cancel', {}));
+            }), error => Promise.reject(error));
         }
         if (res.type === 'PassphraseRequest') {
-            return this._promptPassphrase().then(response => {
-                const { passphrase, passphraseOnDevice } = response;
+            return (0, prompts_1.promptPassphrase)(this.device).then(({ value, passphraseOnDevice }) => {
                 return !passphraseOnDevice
-                    ? this._commonCall('PassphraseAck', { passphrase })
+                    ? this._commonCall('PassphraseAck', { passphrase: value.normalize('NFKD') })
                     : this._commonCall('PassphraseAck', { on_device: true });
-            }, err => this._commonCall('Cancel', {}).catch((e) => {
-                throw err || e;
-            }));
+            }, error => Promise.reject(error));
         }
         if (res.type === 'WordRequest') {
-            return this._promptWord(res.message.type).then(word => this._commonCall('WordAck', { word }), () => this._commonCall('Cancel', {}));
+            return (0, prompts_1.promptWord)(this.device, res.message.type).then(word => this._commonCall('WordAck', { word }), error => Promise.reject(error));
         }
         return Promise.resolve(res);
     }
@@ -304,60 +301,6 @@ class DeviceCommands {
         });
         return message.address;
     }
-    _promptPin(type) {
-        return new Promise((resolve, reject) => {
-            if (this.device.listenerCount(events_1.DEVICE.PIN) > 0) {
-                this._cancelableRequest = reject;
-                this.device.emit(events_1.DEVICE.PIN, this.device, type, (err, pin) => {
-                    this._cancelableRequest = undefined;
-                    if (err || pin == null) {
-                        reject(err);
-                    }
-                    else {
-                        resolve(pin);
-                    }
-                });
-            }
-            else {
-                console.warn('[DeviceCommands] [call] PIN callback not configured, cancelling request');
-                reject(constants_1.ERRORS.TypedError('Runtime', '_promptPin: PIN callback not configured'));
-            }
-        });
-    }
-    _promptPassphrase() {
-        return new Promise((resolve, reject) => {
-            if (this.device.listenerCount(events_1.DEVICE.PASSPHRASE) > 0) {
-                this._cancelableRequest = reject;
-                this.device.emit(events_1.DEVICE.PASSPHRASE, this.device, (response, error) => {
-                    this._cancelableRequest = undefined;
-                    if (error) {
-                        reject(error);
-                    }
-                    else {
-                        resolve(response);
-                    }
-                });
-            }
-            else {
-                console.warn('[DeviceCommands] [call] Passphrase callback not configured, cancelling request');
-                reject(constants_1.ERRORS.TypedError('Runtime', '_promptPassphrase: Passphrase callback not configured'));
-            }
-        });
-    }
-    _promptWord(type) {
-        return new Promise((resolve, reject) => {
-            this._cancelableRequest = reject;
-            this.device.emit(events_1.DEVICE.WORD, this.device, type, (err, word) => {
-                this._cancelableRequest = undefined;
-                if (err || word == null) {
-                    reject(err);
-                }
-                else {
-                    resolve(word.toLocaleLowerCase());
-                }
-            });
-        });
-    }
     async getAccountDescriptor(coinInfo, indexOrPath, derivationType) {
         const address_n = Array.isArray(indexOrPath)
             ? indexOrPath
@@ -410,40 +353,32 @@ class DeviceCommands {
         }
         throw constants_1.ERRORS.TypedError('Runtime', 'DeviceCommands.getAccountDescriptor: unsupported coinInfo.type');
     }
-    async cancel() {
-        if (this._cancelableRequest) {
-            this._cancelableRequest();
-            this._cancelableRequest = undefined;
-            return;
-        }
-        if (this.disposed) {
-            return;
-        }
-        this.dispose();
-        if (!this._cancelableRequestBySend) {
-            if (this.callPromise) {
-                await this.callPromise;
-            }
-            return;
-        }
+    async cancelWithFallback() {
         const { name, version } = this.transport;
         if (name === 'BridgeTransport' && !utils_1.versionUtils.isNewer(version, '2.0.28')) {
             try {
-                await this.device.legacyForceRelease();
+                await (0, utils_1.createTimeoutPromise)(1);
+                await this.device.acquire();
+                await (0, prompts_1.cancelPrompt)(this.device, false);
             }
             catch (err) {
             }
         }
         else {
-            await this.transport.send({
-                protocol: this.device.protocol,
-                session: this.transportSession,
-                name: 'Cancel',
-                data: {},
-            });
-            if (this.callPromise) {
+            return (0, prompts_1.cancelPrompt)(this.device, false);
+        }
+    }
+    async cancel() {
+        if (this.disposed) {
+            return;
+        }
+        this.dispose();
+        if (this.callPromise) {
+            try {
                 await this.callPromise;
             }
+            catch {
+            }
         }
     }
 }

package/lib/device/DeviceList.d.ts

@@ -25,7 +25,7 @@ export interface IDeviceList {
     dispose: DeviceList['dispose'];
 }
 export declare const assertDeviceListConnected: (deviceList: IDeviceList) => asserts deviceList is DeviceList;
-type ConstructorParams = Pick<ConnectSettings, 'priority' | 'debug'> & {
+type ConstructorParams = Pick<ConnectSettings, 'priority' | 'debug' | '_sessionsBackgroundUrl'> & {
     messages: Record<string, any>;
 };
 type InitParams = Pick<ConnectSettings, 'pendingTransportEvent' | 'transportReconnect'>;
@@ -41,7 +41,7 @@ export declare class DeviceList extends TypedEmitter<DeviceListEvents> implement
     private transportCommonArgs;
     isConnected(): this is DeviceList;
     pendingConnection(): Promise<void> | undefined;
-    constructor({ messages, priority, debug }: ConstructorParams);
+    constructor({ messages, priority, debug, _sessionsBackgroundUrl }: ConstructorParams);
     private createTransport;
     setTransports(transports: ConnectSettings['transports']): void;
     private onTransportUpdate;

package/lib/device/DeviceList.js

@@ -42,18 +42,17 @@ class DeviceList extends utils_1.TypedEmitter {
     pendingConnection() {
         return this.initPromise;
     }
-    constructor({ messages, priority, debug }) {
+    constructor({ messages, priority, debug, _sessionsBackgroundUrl }) {
         super();
         this.devices = {};
         this.creatingDevicesDescriptors = {};
         this.createDevicesQueue = [];
         const transportLogger = (0, debug_1.initLog)('@trezor/transport', debug);
-        const abortController = new AbortController();
         this.authPenaltyManager = createAuthPenaltyManager(priority);
         this.transportCommonArgs = {
             messages,
             logger: transportLogger,
-            signal: abortController.signal,
+            sessionsBackgroundUrl: _sessionsBackgroundUrl,
         };
         this.transports = [
             new transport_1.BridgeTransport({

package/lib/device/prompts.d.ts

@@ -0,0 +1,15 @@
+import { Messages } from '@trezor/transport';
+import type { Device } from './Device';
+export type PromptCallback<T> = (response: T | null, error?: Error) => void;
+export declare const cancelPrompt: (device: Device, expectResponse?: boolean) => Promise<{
+    readonly success: false;
+    readonly error: "session not found";
+}> | import("@trezor/transport/lib/types").AsyncResultWithTypedError<import("@trezor/protobuf").MessageFromTrezor, "session not found" | "Network request failed" | "Wrong result type." | "other call in progress" | "Malformed protocol format" | "device disconnected during action" | "unexpected error" | "Aborted by timeout" | "Aborted by signal" | "This transport can not be used in this environment" | "device not found" | "Unable to open device" | "A transfer error has occurred."> | import("@trezor/transport/lib/types").AsyncResultWithTypedError<undefined, "session not found" | "Network request failed" | "Wrong result type." | "other call in progress" | "Malformed protocol format" | "device disconnected during action" | "unexpected error" | "Aborted by timeout" | "Aborted by signal" | "This transport can not be used in this environment" | "device not found" | "Unable to open device" | "A transfer error has occurred.">;
+export declare const promptPassphrase: (device: Device) => Promise<{
+    value: string;
+    passphraseOnDevice?: boolean;
+    save?: boolean;
+}>;
+export declare const promptPin: (device: Device, type?: Messages.PinMatrixRequestType) => Promise<string>;
+export declare const promptWord: (device: Device, type: Messages.WordRequestType) => Promise<string>;
+//# sourceMappingURL=prompts.d.ts.map

package/lib/device/prompts.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptWord = exports.promptPin = exports.promptPassphrase = exports.cancelPrompt = void 0;
+const transport_1 = require("@trezor/transport");
+const constants_1 = require("../constants");
+const events_1 = require("../events");
+const cancelPrompt = (device, expectResponse = true) => {
+    if (!device.transportSession) {
+        return Promise.resolve({
+            success: false,
+            error: transport_1.TRANSPORT_ERROR.SESSION_NOT_FOUND,
+        });
+    }
+    const cancelArgs = {
+        session: device.transportSession,
+        name: 'Cancel',
+        data: {},
+        protocol: device.protocol,
+    };
+    return expectResponse ? device.transport.call(cancelArgs) : device.transport.send(cancelArgs);
+};
+exports.cancelPrompt = cancelPrompt;
+const prompt = (event, ...[device, ...args]) => {
+    return new Promise((resolve, reject) => {
+        const cancelAndReject = (error) => (0, exports.cancelPrompt)(device).then(onCancel => {
+            var _a;
+            return reject(error ||
+                new Error(onCancel.success
+                    ? (_a = onCancel.payload) === null || _a === void 0 ? void 0 : _a.message.message
+                    : onCancel.error));
+        });
+        if (device.listenerCount(event) > 0) {
+            device.setCancelableAction(cancelAndReject);
+            const callback = (...[response, error]) => {
+                device.clearCancelableAction();
+                if (error || response == null) {
+                    cancelAndReject(error);
+                }
+                else {
+                    resolve(response);
+                }
+            };
+            const emitArgs = [event, device, ...args, callback];
+            device.emit(...emitArgs);
+        }
+        else {
+            cancelAndReject(constants_1.ERRORS.TypedError('Runtime', `${event} callback not configured`));
+        }
+    });
+};
+const promptPassphrase = (device) => {
+    return prompt(events_1.DEVICE.PASSPHRASE, device);
+};
+exports.promptPassphrase = promptPassphrase;
+const promptPin = (device, type) => {
+    return prompt(events_1.DEVICE.PIN, device, type);
+};
+exports.promptPin = promptPin;
+const promptWord = (device, type) => {
+    return prompt(events_1.DEVICE.WORD, device, type);
+};
+exports.promptWord = promptWord;
+//# sourceMappingURL=prompts.js.map

package/lib/events/ui-response.d.ts

@@ -39,11 +39,11 @@ export interface UiResponseDevice {
 }
 export interface UiResponsePin {
     type: typeof UI_RESPONSE.RECEIVE_PIN;
-    payload: string;
+    payload: string | undefined;
 }
 export interface UiResponseWord {
     type: typeof UI_RESPONSE.RECEIVE_WORD;
-    payload: string;
+    payload: string | undefined;
 }
 export interface UiResponsePassphrase {
     type: typeof UI_RESPONSE.RECEIVE_PASSPHRASE;
@@ -51,7 +51,7 @@ export interface UiResponsePassphrase {
         value: string;
         passphraseOnDevice?: boolean;
         save?: boolean;
-    };
+    } | undefined;
 }
 export interface UiResponsePassphraseAction {
     type: typeof UI_RESPONSE.INVALID_PASSPHRASE_ACTION;

package/lib/types/api/applySettings.d.ts

@@ -3,19 +3,19 @@ import { PROTO } from '../../constants';
 import type { Params, Response } from '../params';
 export type ApplySettings = Static<typeof ApplySettings>;
 export declare const ApplySettings: import("@trezor/schema-utils").TObject<{
-    language: import("@sinclair/typebox/build/esm/index.mjs").TOptional<import("@sinclair/typebox/build/esm/index.mjs").TString>;
-    label: import("@sinclair/typebox/build/esm/index.mjs").TOptional<import("@sinclair/typebox/build/esm/index.mjs").TString>;
-    passphrase_always_on_device: import("@sinclair/typebox/build/esm/index.mjs").TOptional<import("@sinclair/typebox/build/esm/index.mjs").TBoolean>;
-    safety_checks: import("@sinclair/typebox/build/esm/index.mjs").TOptional<import("@trezor/schema-utils/lib/custom-types/keyof-enum").TKeyOfEnum<typeof PROTO.Enum_SafetyCheckLevel>>;
-    auto_lock_delay_ms: import("@sinclair/typebox/build/esm/index.mjs").TOptional<import("@sinclair/typebox/build/esm/index.mjs").TNumber>;
-    display_rotation: import("@sinclair/typebox/build/esm/index.mjs").TOptional<import("@sinclair/typebox/build/esm/index.mjs").TNumber>;
-    experimental_features: import("@sinclair/typebox/build/esm/index.mjs").TOptional<import("@sinclair/typebox/build/esm/index.mjs").TBoolean>;
-    hide_passphrase_from_host: import("@sinclair/typebox/build/esm/index.mjs").TOptional<import("@sinclair/typebox/build/esm/index.mjs").TBoolean>;
-    haptic_feedback: import("@sinclair/typebox/build/esm/index.mjs").TOptional<import("@sinclair/typebox/build/esm/index.mjs").TBoolean>;
-    use_passphrase: import("@sinclair/typebox/build/esm/index.mjs").TOptional<import("@sinclair/typebox/build/esm/index.mjs").TBoolean>;
-    homescreen: import("@sinclair/typebox/build/esm/index.mjs").TOptional<import("@sinclair/typebox/build/esm/index.mjs").TString>;
-    _passphrase_source: import("@sinclair/typebox/build/esm/index.mjs").TOptional<import("@sinclair/typebox/build/esm/index.mjs").TNumber>;
-    passphrase_source: import("@sinclair/typebox/build/esm/index.mjs").TOptional<import("@sinclair/typebox/build/esm/index.mjs").TNumber>;
+    language: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    label: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    passphrase_always_on_device: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    safety_checks: import("@sinclair/typebox").TOptional<import("@trezor/schema-utils/lib/custom-types/keyof-enum").TKeyOfEnum<typeof PROTO.Enum_SafetyCheckLevel>>;
+    auto_lock_delay_ms: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    display_rotation: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    experimental_features: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    hide_passphrase_from_host: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    haptic_feedback: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    use_passphrase: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    homescreen: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    _passphrase_source: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    passphrase_source: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
 }>;
 export declare function applySettings(params: Params<ApplySettings>): Response<PROTO.Success>;
 //# sourceMappingURL=applySettings.d.ts.map