@trezor/connect 9.1.8 → 9.1.10

package/lib/data/deviceAuthenticityConfig.d.ts

@@ -1,15 +1,21 @@
-import { PROTO } from '../constants';
-type CertPubKeys = {
-    rootPubKeys: string[];
-    caPubKeys: string[];
-};
-type ModelPubKeys = Record<PROTO.DeviceModelInternal.T2B1, CertPubKeys & {
-    debug?: CertPubKeys;
-}> & Partial<Record<Exclude<PROTO.DeviceModelInternal, 'T2B1'>, undefined>>;
-export interface DeviceAuthenticityConfig extends ModelPubKeys {
-    version: number;
-    timestamp: string;
-}
+import { Static } from '@trezor/schema-utils';
+export type DeviceAuthenticityConfig = Static<typeof DeviceAuthenticityConfig>;
+export declare const DeviceAuthenticityConfig: import("@sinclair/typebox").TIntersect<[import("@sinclair/typebox").TIntersect<[import("@sinclair/typebox").TObject<{
+    T2B1: import("@sinclair/typebox").TIntersect<[import("@sinclair/typebox").TObject<{
+        rootPubKeys: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+        caPubKeys: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+    }>, import("@sinclair/typebox").TObject<{
+        debug: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+            rootPubKeys: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            caPubKeys: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+        }>>;
+    }>]>;
+}>, import("@sinclair/typebox").TObject<{
+    T1B1: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUndefined>;
+    T2T1: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUndefined>;
+}>]>, import("@sinclair/typebox").TObject<{
+    version: import("@sinclair/typebox").TNumber;
+    timestamp: import("@sinclair/typebox").TString;
+}>]>;
 export declare const deviceAuthenticityConfig: DeviceAuthenticityConfig;
-export {};
 //# sourceMappingURL=deviceAuthenticityConfig.d.ts.map

package/lib/data/deviceAuthenticityConfig.js

@@ -1,6 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deviceAuthenticityConfig = void 0;
+exports.deviceAuthenticityConfig = exports.DeviceAuthenticityConfig = void 0;
+const schema_utils_1 = require("@trezor/schema-utils");
+const constants_1 = require("../constants");
+const CertPubKeys = schema_utils_1.Type.Object({
+    rootPubKeys: schema_utils_1.Type.Array(schema_utils_1.Type.String()),
+    caPubKeys: schema_utils_1.Type.Array(schema_utils_1.Type.String()),
+});
+const ModelPubKeys = schema_utils_1.Type.Intersect([
+    schema_utils_1.Type.Record(schema_utils_1.Type.Literal(constants_1.PROTO.DeviceModelInternal.T2B1), schema_utils_1.Type.Intersect([
+        CertPubKeys,
+        schema_utils_1.Type.Object({
+            debug: schema_utils_1.Type.Optional(CertPubKeys),
+        }),
+    ])),
+    schema_utils_1.Type.Partial(schema_utils_1.Type.Record(schema_utils_1.Type.Exclude(schema_utils_1.Type.KeyOfEnum(constants_1.PROTO.DeviceModelInternal), schema_utils_1.Type.Literal('T2B1')), schema_utils_1.Type.Undefined())),
+]);
+exports.DeviceAuthenticityConfig = schema_utils_1.Type.Intersect([
+    ModelPubKeys,
+    schema_utils_1.Type.Object({
+        version: schema_utils_1.Type.Number(),
+        timestamp: schema_utils_1.Type.String(),
+    }),
+]);
 exports.deviceAuthenticityConfig = {
     version: 1,
     timestamp: '2023-12-14T12:00:00+00:00',

package/lib/data/firmwareInfo.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getReleases = exports.getRelease = exports.getFirmwareStatus = exports.getInfo = exports.parseFirmware = void 0;
-const utils_1 = require("@trezor/utils");
+const tslib_1 = require("tslib");
+const versionUtils = tslib_1.__importStar(require("@trezor/utils/lib/versionUtils"));
 const firmwareUtils_1 = require("../utils/firmwareUtils");
 const types_1 = require("../types");
 const releases = {
@@ -24,7 +25,7 @@ const getChangelog = (releases, features) => {
             return null;
         }
         if (features.firmware_present && features.major_version === 2) {
-            return releases.filter(r => utils_1.versionUtils.isNewer(r.version, [
+            return releases.filter(r => versionUtils.isNewer(r.version, [
                 features.fw_major,
                 features.fw_minor,
                 features.fw_patch,
@@ -32,7 +33,7 @@ const getChangelog = (releases, features) => {
         }
         return releases;
     }
-    return releases.filter(r => utils_1.versionUtils.isNewer(r.version, [
+    return releases.filter(r => versionUtils.isNewer(r.version, [
         features.major_version,
         features.minor_version,
         features.patch_version,
@@ -42,7 +43,7 @@ const isNewer = (release, features) => {
     if (features.major_version === 1 && features.bootloader_mode) {
         return null;
     }
-    return utils_1.versionUtils.isNewer(release.version, [
+    return versionUtils.isNewer(release.version, [
         features.major_version,
         features.minor_version,
         features.patch_version,
@@ -53,14 +54,14 @@ const isRequired = (changelog) => {
         return null;
     return changelog.some(item => item.required);
 };
-const isEqual = (release, latest) => utils_1.versionUtils.isEqual(release.version, latest.version);
+const isEqual = (release, latest) => versionUtils.isEqual(release.version, latest.version);
 const getT1BootloaderVersion = (releases, features) => {
     const { bootloader_mode, major_version, minor_version, patch_version } = features;
     const versionArray = [major_version, minor_version, patch_version];
     if (bootloader_mode) {
         return versionArray;
     }
-    const release = releases.find(({ version }) => utils_1.versionUtils.isEqual(version, versionArray));
+    const release = releases.find(({ version }) => versionUtils.isEqual(version, versionArray));
     return (release === null || release === void 0 ? void 0 : release.bootloader_version) || [1, 0, 0];
 };
 const getIntermediaryVersion = (releases, features, offerLatest) => {
@@ -68,10 +69,10 @@ const getIntermediaryVersion = (releases, features, offerLatest) => {
         return;
     }
     const bootloaderVersion = getT1BootloaderVersion(releases, features);
-    if (utils_1.versionUtils.isNewerOrEqual(bootloaderVersion, [1, 12, 0])) {
+    if (versionUtils.isNewerOrEqual(bootloaderVersion, [1, 12, 0])) {
         return 3;
     }
-    if (utils_1.versionUtils.isNewerOrEqual(bootloaderVersion, [1, 8, 0])) {
+    if (versionUtils.isNewerOrEqual(bootloaderVersion, [1, 8, 0])) {
         return 2;
     }
     return 1;
@@ -79,12 +80,12 @@ const getIntermediaryVersion = (releases, features, offerLatest) => {
 const getSafeReleases = ({ features, releases }) => {
     const { bootloader_mode, major_version, minor_version, patch_version, fw_major, fw_minor, fw_patch, } = features;
     const firmwareVersion = [major_version, minor_version, patch_version];
-    if (!utils_1.versionUtils.isVersionArray(firmwareVersion)) {
+    if (!versionUtils.isVersionArray(firmwareVersion)) {
         return [];
     }
     if (major_version === 2 && bootloader_mode) {
         const fwVersion = [fw_major, fw_minor, fw_patch];
-        if (utils_1.versionUtils.isVersionArray(fwVersion)) {
+        if (versionUtils.isVersionArray(fwVersion)) {
             return (0, firmwareUtils_1.filterSafeListByFirmware)(releases, fwVersion);
         }
         return (0, firmwareUtils_1.filterSafeListByBootloader)(releases, firmwareVersion);

package/lib/data/version.d.ts

@@ -1,3 +1,3 @@
-export declare const VERSION = "9.1.8";
+export declare const VERSION = "9.1.10";
 export declare const DEFAULT_DOMAIN: string;
 //# sourceMappingURL=version.d.ts.map

package/lib/data/version.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_DOMAIN = exports.VERSION = void 0;
-exports.VERSION = '9.1.8';
+exports.VERSION = '9.1.10';
 const versionN = exports.VERSION.split('.').map(s => parseInt(s, 10));
 exports.DEFAULT_DOMAIN = `https://connect.trezor.io/${versionN[0]}/`;
 //# sourceMappingURL=version.js.map

package/lib/device/Device.d.ts

@@ -1,5 +1,5 @@
 import { TypedEmitter } from '@trezor/utils/lib/typedEventEmitter';
-import { Deferred } from '@trezor/utils';
+import { Deferred } from '@trezor/utils/lib/createDeferred';
 import { TransportProtocol } from '@trezor/protocol';
 import { DeviceCommands } from './DeviceCommands';
 import { PROTO, NETWORK } from '../constants';
@@ -89,13 +89,9 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
     getDevicePath(): string;
     isT1(): boolean;
     hasUnexpectedMode(allow: string[], require: string[]): "ui-device_bootloader_mode" | "ui-device_not_in_bootloader_mode" | "ui-device_not_initialized" | "ui-device_seedless" | null;
-    dispose(): import("packages/transport/lib/types").AbortableCall<void, "Network request failed" | "Wrong result type." | "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" | "wrong previous session" | "session not found"> | undefined;
+    dispose(): import("@trezor/transport/lib/types").AbortableCall<void, "Network request failed" | "Wrong result type." | "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" | "wrong previous session" | "session not found"> | undefined;
     getMode(): "normal" | "bootloader" | "initialize" | "seedless";
     toMessageObject(): DeviceTyped;
-    _getNetworkTypeState(): "binance" | "cardano" | "eos" | "ethereum" | "nem" | "ripple" | "solana" | "stellar" | "tezos" | "bitcoin";
-    _setNetworkTypeState(networkType?: NETWORK.NetworkType): void;
-    _altModeChange(networkType?: NETWORK.NetworkType): boolean;
-    _isAltModeNetworkType(networkType?: keyof typeof NETWORK.TYPES): boolean;
     legacyForceRelease(): Promise<void>;
 }
 //# sourceMappingURL=Device.d.ts.map

package/lib/device/Device.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Device = void 0;
+const tslib_1 = require("tslib");
 const typedEventEmitter_1 = require("@trezor/utils/lib/typedEventEmitter");
-const utils_1 = require("@trezor/utils");
+const createDeferred_1 = require("@trezor/utils/lib/createDeferred");
+const versionUtils = tslib_1.__importStar(require("@trezor/utils/lib/versionUtils"));
 const protocol_1 = require("@trezor/protocol");
 const DeviceCommands_1 = require("./DeviceCommands");
 const constants_1 = require("../constants");
@@ -42,7 +44,7 @@ class Device extends typedEventEmitter_1.TypedEmitter {
         }
         this.transport = transport;
         this.originalDescriptor = descriptor;
-        this.firstRunPromise = (0, utils_1.createDeferred)();
+        this.firstRunPromise = (0, createDeferred_1.createDeferred)();
     }
     static fromDescriptor(transport, originalDescriptor) {
         const descriptor = { ...originalDescriptor, session: null };
@@ -122,7 +124,7 @@ class Device extends typedEventEmitter_1.TypedEmitter {
             throw constants_1.ERRORS.TypedError('Device_CallInProgress');
         }
         options = parseRunOptions(options);
-        const runPromise = (0, utils_1.createDeferred)();
+        const runPromise = (0, createDeferred_1.createDeferred)();
         this.runPromise = runPromise;
         this._runInner(fn, options).catch(err => {
             runPromise.reject(err);
@@ -267,8 +269,7 @@ class Device extends typedEventEmitter_1.TypedEmitter {
                 return;
             }
         }
-        const altMode = this._altModeChange(networkType);
-        const expectedState = altMode ? undefined : this.getExternalState();
+        const expectedState = this.getExternalState();
         const state = await this.getCommands().getDeviceState(networkType);
         const uniqueState = `${state}@${this.features.device_id || 'device_id'}:${this.instance}`;
         if (!this.useLegacyPassphrase() && this.features.session_id) {
@@ -330,7 +331,7 @@ class Device extends typedEventEmitter_1.TypedEmitter {
             feat.minor_version,
             feat.patch_version,
         ];
-        if (!utils_1.versionUtils.isEqual(version, this.getVersion())) {
+        if (!versionUtils.isEqual(version, this.getVersion())) {
             this.unavailableCapabilities = (0, deviceFeaturesUtils_1.getUnavailableCapabilities)(feat, (0, coinInfo_1.getAllNetworks)());
             this.firmwareStatus = (0, firmwareInfo_1.getFirmwareStatus)(feat);
             this.firmwareRelease = (0, firmwareInfo_1.getRelease)(feat);
@@ -397,7 +398,7 @@ class Device extends typedEventEmitter_1.TypedEmitter {
         if (!this.features)
             return false;
         const modelVersion = typeof versions === 'string' ? versions : versions[this.features.major_version - 1];
-        return utils_1.versionUtils.isNewerOrEqual(this.getVersion().join('.'), modelVersion);
+        return versionUtils.isNewerOrEqual(this.getVersion().join('.'), modelVersion);
     }
     isUsed() {
         return typeof this.originalDescriptor.session === 'string';
@@ -506,26 +507,6 @@ class Device extends typedEventEmitter_1.TypedEmitter {
             unavailableCapabilities: this.unavailableCapabilities,
         };
     }
-    _getNetworkTypeState() {
-        return this.networkTypeState[this.instance];
-    }
-    _setNetworkTypeState(networkType) {
-        if (typeof networkType !== 'string') {
-            delete this.networkTypeState[this.instance];
-        }
-        else {
-            this.networkTypeState[this.instance] = networkType;
-        }
-    }
-    _altModeChange(networkType) {
-        const prevAltMode = this._isAltModeNetworkType(this._getNetworkTypeState());
-        const nextAltMode = this._isAltModeNetworkType(networkType);
-        this._setNetworkTypeState(networkType);
-        return prevAltMode !== nextAltMode;
-    }
-    _isAltModeNetworkType(networkType) {
-        return networkType ? ['cardano'].includes(networkType) : false;
-    }
     async legacyForceRelease() {
         if (this.isUsedHere()) {
             await this.acquire();

package/lib/device/DeviceCommands.d.ts

@@ -1,4 +1,5 @@
-import { Transport, Messages } from '@trezor/transport';
+import { Transport } from '@trezor/transport';
+import * as Messages from '@trezor/protobuf/lib/messages-schema';
 import type { Device } from './Device';
 import type { CoinInfo, BitcoinNetworkInfo } from '../types';
 import type { HDNodeResponse } from '../types/api/getPublicKey';
@@ -29,13 +30,44 @@ export declare class DeviceCommands {
     dispose(): void;
     isDisposed(): boolean;
     unlockPath(params?: Messages.UnlockPath): Promise<TypedResponseMessage<"UnlockedPathRequest">>;
-    getPublicKey(params: Messages.GetPublicKey, unlockPath?: Messages.UnlockPath): Promise<Messages.PublicKey>;
+    getPublicKey(params: Messages.GetPublicKey, unlockPath?: Messages.UnlockPath): Promise<{
+        root_fingerprint?: number | undefined;
+        node: {
+            private_key?: string | undefined;
+            public_key: string;
+            depth: number;
+            fingerprint: number;
+            child_num: number;
+            chain_code: string;
+        };
+        xpub: string;
+    }>;
     getHDNode(params: Messages.GetPublicKey, options?: {
         coinInfo?: BitcoinNetworkInfo;
         validation?: boolean;
         unlockPath?: Messages.UnlockPath;
-    }): Promise<HDNodeResponse>;
-    getBitcoinHDNode(path: number[], coinInfo?: BitcoinNetworkInfo, validation?: boolean): Promise<HDNodeResponse>;
+    }): Promise<{
+        xpubSegwit?: string | undefined;
+        path: number[];
+        publicKey: string;
+        serializedPath: string;
+        depth: number;
+        fingerprint: number;
+        chainCode: string;
+        childNum: number;
+        xpub: string;
+    }>;
+    getBitcoinHDNode(path: number[], coinInfo?: BitcoinNetworkInfo, validation?: boolean): Promise<{
+        xpubSegwit?: string | undefined;
+        path: number[];
+        publicKey: string;
+        serializedPath: string;
+        depth: number;
+        fingerprint: number;
+        chainCode: string;
+        childNum: number;
+        xpub: string;
+    }>;
     getAddress({ address_n, show_display, multisig, script_type, chunkify }: Messages.GetAddress, coinInfo: BitcoinNetworkInfo): Promise<{
         path: number[];
         serializedPath: string;

package/lib/device/DeviceCommands.js

@@ -3,7 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeviceCommands = void 0;
 const tslib_1 = require("tslib");
 const crypto_1 = require("crypto");
-const utils_1 = require("@trezor/utils");
+const Messages = tslib_1.__importStar(require("@trezor/protobuf/lib/messages-schema"));
+const versionUtils = tslib_1.__importStar(require("@trezor/utils/lib/versionUtils"));
 const constants_1 = require("../constants");
 const events_1 = require("../events");
 const hdnodeUtils = tslib_1.__importStar(require("../utils/hdnodeUtils"));
@@ -11,6 +12,7 @@ const pathUtils_1 = require("../utils/pathUtils");
 const accountUtils_1 = require("../utils/accountUtils");
 const coinInfo_1 = require("../data/coinInfo");
 const debug_1 = require("../utils/debug");
+const schema_utils_1 = require("@trezor/schema-utils");
 const logger = (0, debug_1.initLog)('DeviceCommands');
 const assertType = (res, resType) => {
     const splitResTypes = Array.isArray(resType) ? resType : resType.split('|');
@@ -262,6 +264,7 @@ class DeviceCommands {
         if (this.disposed) {
             throw constants_1.ERRORS.TypedError('Runtime', 'typedCall: DeviceCommands already disposed');
         }
+        (0, schema_utils_1.Assert)(Messages.MessageType.properties[type], msg !== null && msg !== void 0 ? msg : {});
         const response = await this._commonCall(type, msg);
         try {
             assertType(response, resType);
@@ -508,7 +511,7 @@ class DeviceCommands {
             return;
         }
         const { name, version } = this.transport;
-        if (name === 'BridgeTransport' && !utils_1.versionUtils.isNewer(version, '2.0.28')) {
+        if (name === 'BridgeTransport' && !versionUtils.isNewer(version, '2.0.28')) {
             try {
                 await this.device.legacyForceRelease();
             }

package/lib/device/DeviceList.js

@@ -59,7 +59,7 @@ class DeviceList extends typedEventEmitter_1.TypedEmitter {
                         throw constants_1.ERRORS.TypedError('Runtime', `DeviceList.init: transports[] of unexpected type: ${transportType}`);
                 }
             }
-            else if (transportType instanceof transport_1.Transport) {
+            else if ((0, transport_1.isTransportInstance)(transportType)) {
                 if (!transportType.getMessage()) {
                     transportType.updateMessages(this.messages);
                 }

package/lib/events/index.d.ts

@@ -8,6 +8,7 @@ export * from './transport';
 export * from './ui-promise';
 export * from './ui-request';
 export * from './ui-response';
+export * from './webextension';
 export declare const UI: {
     readonly RECEIVE_PERMISSION: "ui-receive_permission";
     readonly RECEIVE_CONFIRMATION: "ui-receive_confirmation";

package/lib/events/index.js

@@ -14,6 +14,7 @@ tslib_1.__exportStar(require("./transport"), exports);
 tslib_1.__exportStar(require("./ui-promise"), exports);
 tslib_1.__exportStar(require("./ui-request"), exports);
 tslib_1.__exportStar(require("./ui-response"), exports);
+tslib_1.__exportStar(require("./webextension"), exports);
 exports.UI = {
     ...ui_request_1.UI_REQUEST,
     ...ui_response_1.UI_RESPONSE,

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

@@ -1,4 +1,4 @@
-import type { Deferred } from '@trezor/utils';
+import type { Deferred } from '@trezor/utils/lib/createDeferred';
 import type { DEVICE } from './device';
 import type { Device } from '../device/Device';
 import type { UiResponseEvent } from './ui-response';

package/lib/events/webextension.d.ts

@@ -0,0 +1,7 @@
+export declare const WEBEXTENSION: {
+    USB_PERMISSIONS_BROADCAST: string;
+    USB_PERMISSIONS_INIT: string;
+    USB_PERMISSIONS_CLOSE: string;
+    USB_PERMISSIONS_FINISHED: string;
+};
+//# sourceMappingURL=webextension.d.ts.map

package/lib/events/webextension.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WEBEXTENSION = void 0;
+exports.WEBEXTENSION = {
+    USB_PERMISSIONS_BROADCAST: 'usb-permissions',
+    USB_PERMISSIONS_INIT: 'usb-permissions-init',
+    USB_PERMISSIONS_CLOSE: 'usb-permissions-close',
+    USB_PERMISSIONS_FINISHED: 'usb-permissions-finished',
+};
+//# sourceMappingURL=webextension.js.map

package/lib/index.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import EventEmitter from 'events';
-import { Deferred } from '@trezor/utils';
+import { Deferred } from '@trezor/utils/lib/createDeferred';
 export declare const eventEmitter: EventEmitter;
 export declare const messagePromises: {
     [key: number]: Deferred<any>;

package/lib/index.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.messagePromises = exports.eventEmitter = void 0;
 const tslib_1 = require("tslib");
 const events_1 = tslib_1.__importDefault(require("events"));
-const utils_1 = require("@trezor/utils");
+const createDeferred_1 = require("@trezor/utils/lib/createDeferred");
 const core_1 = require("./core");
 const factory_1 = require("./factory");
 const connectSettings_1 = require("./data/connectSettings");
@@ -82,7 +82,7 @@ function postMessage(message, usePromise = true) {
     }
     if (usePromise) {
         _messageID++;
-        exports.messagePromises[_messageID] = (0, utils_1.createDeferred)();
+        exports.messagePromises[_messageID] = (0, createDeferred_1.createDeferred)();
         const { promise } = exports.messagePromises[_messageID];
         _core.handleMessage({ ...message, id: _messageID });
         return promise;

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

@@ -1,4 +1,20 @@
-import type { PROTO } from '../../constants';
+import { Static } from '@trezor/schema-utils';
+import { PROTO } from '../../constants';
 import type { Params, Response } from '../params';
-export declare function applySettings(params: Params<PROTO.ApplySettings>): Response<PROTO.Success>;
+export type ApplySettings = Static<typeof ApplySettings>;
+export declare const ApplySettings: import("@sinclair/typebox").TObject<{
+    passphrase_source: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    language: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    label: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    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>;
+    auto_lock_delay_ms: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    display_rotation: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    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>>;
+    experimental_features: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    hide_passphrase_from_host: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+}>;
+export declare function applySettings(params: Params<ApplySettings>): Response<PROTO.Success>;
 //# sourceMappingURL=applySettings.d.ts.map

package/lib/types/api/applySettings.js

@@ -1,3 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApplySettings = void 0;
+const schema_utils_1 = require("@trezor/schema-utils");
+const constants_1 = require("../../constants");
+exports.ApplySettings = schema_utils_1.Type.Composite([
+    constants_1.PROTO.ApplySettings,
+    schema_utils_1.Type.Object({
+        passphrase_source: schema_utils_1.Type.Optional(schema_utils_1.Type.Number()),
+    }),
+]);
 //# sourceMappingURL=applySettings.js.map

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

@@ -1,9 +1,26 @@
-import type { DeviceAuthenticityConfig } from '../../data/deviceAuthenticityConfig';
+import { Static } from '@trezor/schema-utils';
 import type { Params, Response } from '../params';
-export interface AuthenticateDeviceParams {
-    config?: DeviceAuthenticityConfig;
-    allowDebugKeys?: boolean;
-}
+export type AuthenticateDeviceParams = Static<typeof AuthenticateDeviceParams>;
+export declare const AuthenticateDeviceParams: import("@sinclair/typebox").TObject<{
+    config: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TIntersect<[import("@sinclair/typebox").TIntersect<[import("@sinclair/typebox").TObject<{
+        T2B1: import("@sinclair/typebox").TIntersect<[import("@sinclair/typebox").TObject<{
+            rootPubKeys: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            caPubKeys: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+        }>, import("@sinclair/typebox").TObject<{
+            debug: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+                rootPubKeys: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+                caPubKeys: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            }>>;
+        }>]>;
+    }>, import("@sinclair/typebox").TObject<{
+        T1B1: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUndefined>;
+        T2T1: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUndefined>;
+    }>]>, import("@sinclair/typebox").TObject<{
+        version: import("@sinclair/typebox").TNumber;
+        timestamp: import("@sinclair/typebox").TString;
+    }>]>>;
+    allowDebugKeys: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+}>;
 export type AuthenticateDeviceResult = {
     valid: true;
     caPubKey: string;

package/lib/types/api/authenticateDevice.js

@@ -1,3 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthenticateDeviceParams = void 0;
+const schema_utils_1 = require("@trezor/schema-utils");
+const deviceAuthenticityConfig_1 = require("../../data/deviceAuthenticityConfig");
+exports.AuthenticateDeviceParams = schema_utils_1.Type.Object({
+    config: schema_utils_1.Type.Optional(deviceAuthenticityConfig_1.DeviceAuthenticityConfig),
+    allowDebugKeys: schema_utils_1.Type.Optional(schema_utils_1.Type.Boolean()),
+});
 //# sourceMappingURL=authenticateDevice.js.map

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

@@ -1,15 +1,17 @@
-import type { PROTO } from '../../constants';
-import type { Params, Response, DerivationPath } from '../params';
-export interface AuthorizeCoinjoin {
-    path: DerivationPath;
-    coordinator: string;
-    maxRounds: number;
-    maxCoordinatorFeeRate: number;
-    maxFeePerKvbyte: number;
-    coin?: string;
-    scriptType?: PROTO.InternalInputScriptType;
-    amountUnit?: PROTO.AmountUnit;
-    preauthorized?: boolean;
-}
+import type { Params, Response } from '../params';
+import { Static } from '@trezor/schema-utils';
+import { PROTO } from '../../constants';
+export type AuthorizeCoinjoin = Static<typeof AuthorizeCoinjoin>;
+export declare const AuthorizeCoinjoin: import("@sinclair/typebox").TObject<{
+    path: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TNumber>]>;
+    coordinator: import("@sinclair/typebox").TString;
+    maxRounds: import("@sinclair/typebox").TNumber;
+    maxCoordinatorFeeRate: import("@sinclair/typebox").TNumber;
+    maxFeePerKvbyte: import("@sinclair/typebox").TNumber;
+    coin: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    scriptType: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"SPENDADDRESS">, import("@sinclair/typebox").TLiteral<"SPENDMULTISIG">, import("@sinclair/typebox").TLiteral<"SPENDWITNESS">, import("@sinclair/typebox").TLiteral<"SPENDP2SHWITNESS">, import("@sinclair/typebox").TLiteral<"SPENDTAPROOT">]>>;
+    amountUnit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TEnum<typeof PROTO.AmountUnit>>;
+    preauthorized: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+}>;
 export declare function authorizeCoinjoin(params: Params<AuthorizeCoinjoin>): Response<PROTO.Success>;
 //# sourceMappingURL=authorizeCoinjoin.d.ts.map

package/lib/types/api/authorizeCoinjoin.js

@@ -1,3 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthorizeCoinjoin = void 0;
+const schema_utils_1 = require("@trezor/schema-utils");
+const params_1 = require("../params");
+const constants_1 = require("../../constants");
+exports.AuthorizeCoinjoin = schema_utils_1.Type.Object({
+    path: params_1.DerivationPath,
+    coordinator: schema_utils_1.Type.String(),
+    maxRounds: schema_utils_1.Type.Number(),
+    maxCoordinatorFeeRate: schema_utils_1.Type.Number(),
+    maxFeePerKvbyte: schema_utils_1.Type.Number(),
+    coin: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
+    scriptType: schema_utils_1.Type.Optional(constants_1.PROTO.InternalInputScriptType),
+    amountUnit: schema_utils_1.Type.Optional(constants_1.PROTO.EnumAmountUnit),
+    preauthorized: schema_utils_1.Type.Optional(schema_utils_1.Type.Boolean()),
+});
 //# sourceMappingURL=authorizeCoinjoin.js.map