@unwanted/matrix-sdk-mini 34.12.0-1 → 34.12.0-3

package/lib/client.d.ts

@@ -2,39 +2,24 @@
  * This is an internal module. See {@link MatrixClient} for the public class.
  */
 import { Optional } from "matrix-events-sdk";
-import type { IDeviceKeys, IMegolmSessionData, IOneTimeKey } from "./@types/crypto.ts";
 import { ISyncStateData, SetPresence, SyncApi, SyncApiOptions, SyncState } from "./sync.ts";
 import { EventStatus, IContent, IDecryptOptions, IEvent, MatrixEvent, MatrixEventEvent, MatrixEventHandlerMap, PushDetails } from "./models/event.ts";
-import { CallEvent, CallEventHandlerMap, MatrixCall } from "./webrtc/call.ts";
 import { Filter, IFilterDefinition } from "./filter.ts";
-import { CallEventHandler, CallEventHandlerEvent, CallEventHandlerEventHandlerMap } from "./webrtc/callEventHandler.ts";
-import { GroupCallEventHandler, GroupCallEventHandlerEvent, GroupCallEventHandlerEventHandlerMap } from "./webrtc/groupCallEventHandler.ts";
 import { QueryDict } from "./utils.ts";
 import { Direction, EventTimeline } from "./models/event-timeline.ts";
 import { IActionsObject, PushProcessor } from "./pushprocessor.ts";
 import { AutoDiscoveryAction } from "./autodiscovery.ts";
-import { IExportedDevice as IExportedOlmDevice } from "./crypto/OlmDevice.ts";
-import { IOlmDevice } from "./crypto/algorithms/megolm.ts";
 import { TypedReEmitter } from "./ReEmitter.ts";
-import { IRoomEncryption } from "./crypto/RoomList.ts";
 import { Logger } from "./logger.ts";
 import { SERVICE_TYPES } from "./service-types.ts";
 import { FileType, HttpApiEvent, HttpApiEventHandlerMap, IHttpOpts, IRequestOpts, MatrixError, MatrixHttpApi, TokenRefreshFunction, Upload, UploadOpts, UploadResponse } from "./http-api/index.ts";
-import { Crypto, CryptoEvent as LegacyCryptoEvent, CryptoEventHandlerMap as LegacyCryptoEventHandlerMap, ICheckOwnCrossSigningTrustOpts } from "./crypto/index.ts";
-import { DeviceInfo } from "./crypto/deviceinfo.ts";
 import { User, UserEvent, UserEventHandlerMap } from "./models/user.ts";
-import { IDehydratedDevice, IDehydratedDeviceKeyInfo } from "./crypto/dehydration.ts";
-import { IKeyBackupInfo, IKeyBackupPrepareOpts, IKeyBackupRestoreOpts, IKeyBackupRestoreResult } from "./crypto/keybackup.ts";
 import { IIdentityServerProvider } from "./@types/IIdentityServerProvider.ts";
 import { MatrixScheduler } from "./scheduler.ts";
 import { BeaconEvent, BeaconEventHandlerMap } from "./models/beacon.ts";
 import { AuthDict } from "./interactive-auth.ts";
 import { IMinimalEvent, IRoomEvent, IStateEvent } from "./sync-accumulator.ts";
-import { CrossSigningKey, ICreateSecretStorageOpts, IEncryptedEventInfo, IRecoveryKey } from "./crypto/api.ts";
 import { EventTimelineSet } from "./models/event-timeline-set.ts";
-import { VerificationRequest } from "./crypto/verification/request/VerificationRequest.ts";
-import { VerificationBase as Verification } from "./crypto/verification/Base.ts";
-import { CrossSigningInfo, DeviceTrustLevel, ICacheCallbacks, UserTrustLevel } from "./crypto/CrossSigning.ts";
 import { Room, RoomEvent, RoomEventHandlerMap, RoomNameState } from "./models/room.ts";
 import { RoomMemberEvent, RoomMemberEventHandlerMap } from "./models/room-member.ts";
 import { RoomStateEvent, RoomStateEventHandlerMap } from "./models/room-state.ts";
@@ -42,19 +27,14 @@ import { DelayedEventInfo, IAddThreePidOnlyBody, IBindThreePidBody, ICreateRoomO
 import { EventType, RelationType, RoomType, StateEvents, TimelineEvents } from "./@types/event.ts";
 import { IdServerUnbindResult, JoinRule, Preset, Visibility } from "./@types/partials.ts";
 import { EventMapper, MapperOpts } from "./event-mapper.ts";
-import { IKeyBackup, IKeyBackupCheck, IPreparedKeyBackupVersion, TrustInfo } from "./crypto/backup.ts";
 import { MSC3089TreeSpace } from "./models/MSC3089TreeSpace.ts";
 import { ISignatures } from "./@types/signed.ts";
 import { IStore } from "./store/index.ts";
-import { ISecretRequest } from "./crypto/SecretStorage.ts";
 import { IEventWithRoomId, ISearchRequestBody, ISearchResponse, ISearchResults, IStateEventWithRoomId } from "./@types/search.ts";
 import { ISynapseAdminDeactivateResponse, ISynapseAdminWhoisResponse } from "./@types/synapse.ts";
 import { IHierarchyRoom } from "./@types/spaces.ts";
 import { IPusher, IPusherRequest, IPushRule, IPushRules, PushRuleAction, PushRuleKind, RuleId } from "./@types/PushRules.ts";
 import { IThreepid } from "./@types/threepids.ts";
-import { CryptoStore, OutgoingRoomKeyRequest } from "./crypto/store/base.ts";
-import { GroupCall, GroupCallIntent, GroupCallType, IGroupCallDataChannelOptions } from "./webrtc/groupCall.ts";
-import { MediaHandler } from "./webrtc/mediaHandler.ts";
 import { ILoginFlowsResponse, IRefreshTokenResponse, LoginRequest, LoginResponse, LoginTokenPostResponse, SSOAction } from "./@types/auth.ts";
 import { TypedEventEmitter } from "./models/typed-event-emitter.ts";
 import { ReceiptType } from "./@types/read_receipts.ts";
@@ -68,11 +48,7 @@ import { IgnoredInvites } from "./models/invites-ignorer.ts";
 import { UIAResponse } from "./@types/uia.ts";
 import { LocalNotificationSettings } from "./@types/local_notifications.ts";
 import { Feature, ServerSupport } from "./feature.ts";
-import { BootstrapCrossSigningOpts, CrossSigningKeyInfo, CryptoApi, ImportRoomKeysOpts, CryptoEvent, CryptoEventHandlerMap, CryptoCallbacks } from "./crypto-api/index.ts";
-import { DeviceInfoMap } from "./crypto/DeviceList.ts";
-import { AddSecretStorageKeyOpts, SecretStorageKeyDescription, ServerSideSecretStorage } from "./secret-storage.ts";
 import { RegisterRequest, RegisterResponse } from "./@types/registration.ts";
-import { MatrixRTCSessionManager } from "./matrixrtc/MatrixRTCSessionManager.ts";
 import { Membership } from "./@types/membership.ts";
 import { RoomMessageEventContent } from "./@types/events.ts";
 import { ImageInfo } from "./@types/media.ts";
@@ -81,7 +57,6 @@ export type Store = IStore;
 export type ResetTimelineCallback = (roomId: string) => boolean;
 export declare const UNSTABLE_MSC3852_LAST_SEEN_UA: UnstableValue<"last_seen_user_agent", "org.matrix.msc3852.last_seen_user_agent">;
 interface IExportedDevice {
-    olmDevice: IExportedOlmDevice;
     userId: string;
     deviceId: string;
 }
@@ -99,19 +74,6 @@ export interface ICreateClientOpts {
      * will create a default store if needed.
      */
     store?: Store;
-    /**
-     * A store to be used for end-to-end crypto session data.
-     * The `createClient` helper will create a default store if needed. Calls the factory supplied to
-     * {@link setCryptoStoreFactory} if unspecified; or if no factory has been
-     * specified, uses a default implementation (indexeddb in the browser,
-     * in-memory otherwise).
-     *
-     * This is only used for the legacy crypto implementation (as used by {@link MatrixClient#initCrypto}),
-     * but if you use the rust crypto implementation ({@link MatrixClient#initRustCrypto}) and the device
-     * previously used legacy crypto (so must be migrated), then this must still be provided, so that the
-     * data can be migrated from the legacy store.
-     */
-    cryptoStore?: CryptoStore;
     /**
      * The scheduler to use. If not
      * specified, this client will not retry requests on failure. This client
@@ -227,10 +189,6 @@ export interface ICreateClientOpts {
      */
     useE2eForGroupCall?: boolean;
     livekitServiceURL?: string;
-    /**
-     * Crypto callbacks provided by the application
-     */
-    cryptoCallbacks?: CryptoCallbacks;
     /**
      * Method to generate room names for empty rooms and rooms names based on membership.
      * Defaults to a built-in English handler with basic pluralisation.
@@ -325,12 +283,6 @@ export declare const UNSTABLE_MSC2666_MUTUAL_ROOMS = "uk.half-shot.msc2666.mutua
 export declare const UNSTABLE_MSC2666_QUERY_MUTUAL_ROOMS = "uk.half-shot.msc2666.query_mutual_rooms";
 export declare const UNSTABLE_MSC4140_DELAYED_EVENTS = "org.matrix.msc4140";
 export declare const UNSTABLE_MSC4133_EXTENDED_PROFILES = "uk.tcpip.msc4133";
-declare enum CrossSigningKeyType {
-    MasterKey = "master_key",
-    SelfSigningKey = "self_signing_key",
-    UserSigningKey = "user_signing_key"
-}
-export type CrossSigningKeys = Record<CrossSigningKeyType, CrossSigningKeyInfo>;
 export type SendToDeviceContentMap = Map<string, Map<string, Record<string, any>>>;
 export interface ISignedKey {
     keys: Record<string, string>;
@@ -339,7 +291,6 @@ export interface ISignedKey {
     algorithms: string[];
     device_id: string;
 }
-export type KeySignatures = Record<string, Record<string, CrossSigningKeyInfo | ISignedKey>>;
 export interface IUploadKeySignaturesResponse {
     failures: Record<string, Record<string, {
         errcode: string;
@@ -409,11 +360,6 @@ export interface IRequestMsisdnTokenResponse extends IRequestTokenResponse {
     success: boolean;
     intl_fmt: string;
 }
-export interface IUploadKeysRequest {
-    "device_keys"?: Required<IDeviceKeys>;
-    "one_time_keys"?: Record<string, IOneTimeKey>;
-    "org.matrix.msc2732.fallback_keys"?: Record<string, IOneTimeKey>;
-}
 export interface IQueryKeysRequest {
     device_keys: {
         [userId: string]: string[];
@@ -502,33 +448,6 @@ export interface Keys {
     usage: string[];
     user_id: string;
 }
-export interface SigningKeys extends Keys {
-    signatures: ISignatures;
-}
-export interface DeviceKeys {
-    [deviceId: string]: IDeviceKeys & {
-        unsigned?: {
-            device_display_name: string;
-        };
-    };
-}
-export interface IDownloadKeyResult {
-    failures: {
-        [serverName: string]: object;
-    };
-    device_keys: {
-        [userId: string]: DeviceKeys;
-    };
-    master_keys?: {
-        [userId: string]: Keys;
-    };
-    self_signing_keys?: {
-        [userId: string]: SigningKeys;
-    };
-    user_signing_keys?: {
-        [userId: string]: SigningKeys;
-    };
-}
 export interface IClaimOTKsResult {
     failures: {
         [serverName: string]: object;
@@ -620,12 +539,10 @@ export declare enum ClientEvent {
 }
 type RoomEvents = RoomEvent.Name | RoomEvent.Redaction | RoomEvent.RedactionCancelled | RoomEvent.Receipt | RoomEvent.Tags | RoomEvent.LocalEchoUpdated | RoomEvent.HistoryImportedWithinTimeline | RoomEvent.AccountData | RoomEvent.MyMembership | RoomEvent.Timeline | RoomEvent.TimelineReset;
 type RoomStateEvents = RoomStateEvent.Events | RoomStateEvent.Members | RoomStateEvent.NewMember | RoomStateEvent.Update | RoomStateEvent.Marker;
-type LegacyCryptoEvents = LegacyCryptoEvent.KeySignatureUploadFailure | LegacyCryptoEvent.KeyBackupStatus | LegacyCryptoEvent.KeyBackupFailed | LegacyCryptoEvent.KeyBackupSessionsRemaining | LegacyCryptoEvent.KeyBackupDecryptionKeyCached | LegacyCryptoEvent.RoomKeyRequest | LegacyCryptoEvent.RoomKeyRequestCancellation | LegacyCryptoEvent.VerificationRequest | LegacyCryptoEvent.VerificationRequestReceived | LegacyCryptoEvent.DeviceVerificationChanged | LegacyCryptoEvent.UserTrustStatusChanged | LegacyCryptoEvent.KeysChanged | LegacyCryptoEvent.Warning | LegacyCryptoEvent.DevicesUpdated | LegacyCryptoEvent.WillUpdateDevices | LegacyCryptoEvent.LegacyCryptoStoreMigrationProgress;
-type CryptoEvents = (typeof CryptoEvent)[keyof typeof CryptoEvent];
 type MatrixEventEvents = MatrixEventEvent.Decrypted | MatrixEventEvent.Replaced | MatrixEventEvent.VisibilityChange;
 type RoomMemberEvents = RoomMemberEvent.Name | RoomMemberEvent.Typing | RoomMemberEvent.PowerLevel | RoomMemberEvent.Membership;
 type UserEvents = UserEvent.AvatarUrl | UserEvent.DisplayName | UserEvent.Presence | UserEvent.CurrentlyActive | UserEvent.LastPresenceTs;
-export type EmittedEvents = ClientEvent | RoomEvents | RoomStateEvents | LegacyCryptoEvents | CryptoEvents | MatrixEventEvents | RoomMemberEvents | UserEvents | CallEvent | CallEventHandlerEvent.Incoming | GroupCallEventHandlerEvent.Incoming | GroupCallEventHandlerEvent.Outgoing | GroupCallEventHandlerEvent.Ended | GroupCallEventHandlerEvent.Participants | HttpApiEvent.SessionLoggedOut | HttpApiEvent.NoConsent | BeaconEvent;
+export type EmittedEvents = ClientEvent | RoomEvents | RoomStateEvents | MatrixEventEvents | RoomMemberEvents | UserEvents | HttpApiEvent.SessionLoggedOut | HttpApiEvent.NoConsent | BeaconEvent;
 export type ClientEventHandlerMap = {
     /**
      * Fires whenever the SDK's syncing state is updated. The state can be one of:
@@ -821,7 +738,7 @@ export type ClientEventHandlerMap = {
     [ClientEvent.ReceivedVoipEvent]: (event: MatrixEvent) => void;
     [ClientEvent.TurnServers]: (servers: ITurnServer[]) => void;
     [ClientEvent.TurnServersError]: (error: Error, fatal: boolean) => void;
-} & RoomEventHandlerMap & RoomStateEventHandlerMap & LegacyCryptoEventHandlerMap & CryptoEventHandlerMap & MatrixEventHandlerMap & RoomMemberEventHandlerMap & UserEventHandlerMap & CallEventHandlerEventHandlerMap & GroupCallEventHandlerEventHandlerMap & CallEventHandlerMap & HttpApiEventHandlerMap & BeaconEventHandlerMap;
+} & RoomEventHandlerMap & RoomStateEventHandlerMap & MatrixEventHandlerMap & RoomMemberEventHandlerMap & UserEventHandlerMap & HttpApiEventHandlerMap & BeaconEventHandlerMap;
 /**
  * Represents a Matrix Client. Only directly construct this if you want to use
  * custom modules. Normally, {@link createClient} should be used
@@ -858,17 +775,6 @@ export declare class MatrixClient extends TypedEventEmitter<EmittedEvents, Clien
     http: MatrixHttpApi<IHttpOpts & {
         onlyData: true;
     }>;
-    /**
-     * The libolm crypto implementation, if it is in use.
-     *
-     * @deprecated This should not be used. Instead, use the methods exposed directly on this class or
-     * (where they are available) via {@link getCrypto}.
-     */
-    crypto?: Crypto;
-    private cryptoBackend?;
-    cryptoCallbacks: CryptoCallbacks;
-    callEventHandler?: CallEventHandler;
-    groupCallEventHandler?: GroupCallEventHandler;
     supportsCallTransfer: boolean;
     forceTURN: boolean;
     iceCandidatePoolSize: number;
@@ -876,7 +782,6 @@ export declare class MatrixClient extends TypedEventEmitter<EmittedEvents, Clien
     baseUrl: string;
     readonly isVoipWithNoMediaAllowed: boolean;
     useLivekitForGroupCalls: boolean;
-    protected canSupportVoip: boolean;
     protected peekSync: SyncApi | null;
     protected isGuestAccount: boolean;
     protected ongoingScrollbacks: {
@@ -886,7 +791,6 @@ export declare class MatrixClient extends TypedEventEmitter<EmittedEvents, Clien
         };
     };
     protected notifTimelineSet: EventTimelineSet | null;
-    protected cryptoStore?: CryptoStore;
     protected verificationMethods?: string[];
     protected fallbackICEServerAllowed: boolean;
     protected syncApi?: SlidingSyncSdk | SyncApi;
@@ -902,12 +806,7 @@ export declare class MatrixClient extends TypedEventEmitter<EmittedEvents, Clien
     protected serverVersionsPromise?: Promise<IServerVersions>;
     protected clientWellKnown?: IClientWellKnown;
     protected clientWellKnownPromise?: Promise<IClientWellKnown>;
-    protected turnServers: ITurnServer[];
-    protected turnServersExpiry: number;
-    protected checkTurnServersIntervalID?: ReturnType<typeof setInterval>;
-    protected exportedOlmDeviceToImport?: IExportedOlmDevice;
     protected txnCtr: number;
-    protected mediaHandler: MediaHandler;
     protected sessionId: string;
     /** IDs of events which are currently being encrypted.
      *
@@ -918,9 +817,7 @@ export declare class MatrixClient extends TypedEventEmitter<EmittedEvents, Clien
     private useE2eForGroupCall;
     private toDeviceMessageQueue;
     livekitServiceURL?: string;
-    private _secretStorage;
     readonly ignoredInvites: IgnoredInvites;
-    readonly matrixRTC: MatrixRTCSessionManager;
     private serverCapabilitiesService;
     constructor(opts: IMatrixClientCreateOpts);
     set store(newStore: Store);
@@ -942,53 +839,6 @@ export declare class MatrixClient extends TypedEventEmitter<EmittedEvents, Clien
      * clean shutdown.
      */
     stopClient(): void;
-    /**
-     * Try to rehydrate a device if available.  The client must have been
-     * initialized with a `cryptoCallback.getDehydrationKey` option, and this
-     * function must be called before initCrypto and startClient are called.
-     *
-     * @returns Promise which resolves to undefined if a device could not be dehydrated, or
-     *     to the new device ID if the dehydration was successful.
-     * @returns Rejects: with an error response.
-     *
-     * @deprecated MSC2697 device dehydration is not supported for rust cryptography.
-     */
-    rehydrateDevice(): Promise<string | undefined>;
-    /**
-     * Get the current dehydrated device, if any
-     * @returns A promise of an object containing the dehydrated device
-     *
-     * @deprecated MSC2697 device dehydration is not supported for rust cryptography.
-     */
-    getDehydratedDevice(): Promise<IDehydratedDevice | undefined>;
-    /**
-     * Set the dehydration key.  This will also periodically dehydrate devices to
-     * the server.
-     *
-     * @param key - the dehydration key
-     * @param keyInfo - Information about the key.  Primarily for
-     *     information about how to generate the key from a passphrase.
-     * @param deviceDisplayName - The device display name for the
-     *     dehydrated device.
-     * @returns A promise that resolves when the dehydrated device is stored.
-     *
-     * @deprecated Not supported for Rust Cryptography.
-     */
-    setDehydrationKey(key: Uint8Array, keyInfo: IDehydratedDeviceKeyInfo, deviceDisplayName?: string): Promise<void>;
-    /**
-     * Creates a new MSC2967 dehydrated device (without queuing periodic dehydration)
-     * @param key - the dehydration key
-     * @param keyInfo - Information about the key.  Primarily for
-     *     information about how to generate the key from a passphrase.
-     * @param deviceDisplayName - The device display name for the
-     *     dehydrated device.
-     * @returns the device id of the newly created dehydrated device
-     *
-     * @deprecated Not supported for Rust Cryptography. Prefer {@link CryptoApi.startDehydration}.
-     */
-    createDehydratedDevice(key: Uint8Array, keyInfo: IDehydratedDeviceKeyInfo, deviceDisplayName?: string): Promise<string | undefined>;
-    /** @deprecated Not supported for Rust Cryptography. */
-    exportDevice(): Promise<IExportedDevice | undefined>;
     /**
      * Clear any data out of the persistent stores used by the client.
      *
@@ -1028,15 +878,6 @@ export declare class MatrixClient extends TypedEventEmitter<EmittedEvents, Clien
      * @returns session ID
      */
     getSessionId(): string;
-    /**
-     * Check if the runtime environment supports VoIP calling.
-     * @returns True if VoIP is supported.
-     */
-    supportsVoip(): boolean;
-    /**
-     * @returns
-     */
-    getMediaHandler(): MediaHandler;
     /**
      * Set whether VoIP calls are forced to use only TURN
      * candidates. This is the same as the forceTURN option
@@ -1055,40 +896,8 @@ export declare class MatrixClient extends TypedEventEmitter<EmittedEvents, Clien
      * @returns boolean Whether group call signalling will be encrypted
      */
     getUseE2eForGroupCall(): boolean;
-    /**
-     * Creates a new call.
-     * The place*Call methods on the returned call can be used to actually place a call
-     *
-     * @param roomId - The room the call is to be placed in.
-     * @returns the call or null if the browser doesn't support calling.
-     */
-    createCall(roomId: string): MatrixCall | null;
-    /**
-     * Creates a new group call and sends the associated state event
-     * to alert other members that the room now has a group call.
-     *
-     * @param roomId - The room the call is to be placed in.
-     */
-    createGroupCall(roomId: string, type: GroupCallType, isPtt: boolean, intent: GroupCallIntent, dataChannelsEnabled?: boolean, dataChannelOptions?: IGroupCallDataChannelOptions): Promise<GroupCall>;
     getLivekitServiceURL(): string | undefined;
     setLivekitServiceURL(newURL: string): void;
-    /**
-     * Wait until an initial state for the given room has been processed by the
-     * client and the client is aware of any ongoing group calls. Awaiting on
-     * the promise returned by this method before calling getGroupCallForRoom()
-     * avoids races where getGroupCallForRoom is called before the state for that
-     * room has been processed. It does not, however, fix other races, eg. two
-     * clients both creating a group call at the same time.
-     * @param roomId - The room ID to wait for
-     * @returns A promise that resolves once existing group calls in the room
-     *          have been processed.
-     */
-    waitUntilRoomReadyForGroupCalls(roomId: string): Promise<void>;
-    /**
-     * Get an existing group call for the provided room.
-     * @returns The group call or null if it doesn't already exist.
-     */
-    getGroupCallForRoom(roomId: string): GroupCall | null;
     /**
      * Get the current sync state.
      * @returns the sync state, which may be null.
@@ -1167,965 +976,10 @@ export declare class MatrixClient extends TypedEventEmitter<EmittedEvents, Clien
      * @returns A promise which resolves to the capabilities of the homeserver
      */
     fetchCapabilities(): Promise<Capabilities>;
-    /**
-     * Initialise support for end-to-end encryption in this client, using libolm.
-     *
-     * You should call this method after creating the matrixclient, but *before*
-     * calling `startClient`, if you want to support end-to-end encryption.
-     *
-     * It will return a Promise which will resolve when the crypto layer has been
-     * successfully initialised.
-     *
-     * @deprecated libolm is deprecated. Prefer {@link initRustCrypto}.
-     */
-    initCrypto(): Promise<void>;
-    /**
-     * Initialise support for end-to-end encryption in this client, using the rust matrix-sdk-crypto.
-     *
-     * An alternative to {@link initCrypto}.
-     *
-     * @param args.useIndexedDB - True to use an indexeddb store, false to use an in-memory store. Defaults to 'true'.
-     * @param args.storageKey - A key with which to encrypt the indexeddb store. If provided, it must be exactly
-     *    32 bytes of data, and must be the same each time the client is initialised for a given device.
-     *    If both this and `storagePassword` are unspecified, the store will be unencrypted.
-     * @param args.storagePassword - An alternative to `storageKey`. A password which will be used to derive a key to
-     *    encrypt the store with. Deriving a key from a password is (deliberately) a slow operation, so prefer
-     *    to pass a `storageKey` directly where possible.
-     *
-     * @returns a Promise which will resolve when the crypto layer has been
-     *    successfully initialised.
-     */
-    initRustCrypto(args?: {
-        useIndexedDB?: boolean;
-        storageKey?: Uint8Array;
-        storagePassword?: string;
-    }): Promise<void>;
-    /**
-     * Access the server-side secret storage API for this client.
-     */
-    get secretStorage(): ServerSideSecretStorage;
-    /**
-     * Access the crypto API for this client.
-     *
-     * If end-to-end encryption has been enabled for this client (via {@link initCrypto} or {@link initRustCrypto}),
-     * returns an object giving access to the crypto API. Otherwise, returns `undefined`.
-     */
-    getCrypto(): CryptoApi | undefined;
-    /**
-     * Is end-to-end crypto enabled for this client.
-     * @returns True if end-to-end is enabled.
-     * @deprecated prefer {@link getCrypto}
-     */
-    isCryptoEnabled(): boolean;
-    /**
-     * Get the Ed25519 key for this device
-     *
-     * @returns base64-encoded ed25519 key. Null if crypto is
-     *    disabled.
-     *
-     * @deprecated Not supported for Rust Cryptography.Prefer {@link CryptoApi.getOwnDeviceKeys}
-     */
-    getDeviceEd25519Key(): string | null;
-    /**
-     * Get the Curve25519 key for this device
-     *
-     * @returns base64-encoded curve25519 key. Null if crypto is
-     *    disabled.
-     *
-     * @deprecated Not supported for Rust Cryptography. Use {@link CryptoApi.getOwnDeviceKeys}
-     */
-    getDeviceCurve25519Key(): string | null;
     /**
      * @deprecated Does nothing.
      */
     uploadKeys(): Promise<void>;
-    /**
-     * Download the keys for a list of users and stores the keys in the session
-     * store.
-     * @param userIds - The users to fetch.
-     * @param forceDownload - Always download the keys even if cached.
-     *
-     * @returns A promise which resolves to a map userId-\>deviceId-\>`DeviceInfo`
-     *
-     * @deprecated Not supported for Rust Cryptography. Prefer {@link CryptoApi.getUserDeviceInfo}
-     */
-    downloadKeys(userIds: string[], forceDownload?: boolean): Promise<DeviceInfoMap>;
-    /**
-     * Get the stored device keys for a user id
-     *
-     * @param userId - the user to list keys for.
-     *
-     * @returns list of devices
-     * @deprecated Not supported for Rust Cryptography. Prefer {@link CryptoApi.getUserDeviceInfo}
-     */
-    getStoredDevicesForUser(userId: string): DeviceInfo[];
-    /**
-     * Get the stored device key for a user id and device id
-     *
-     * @param userId - the user to list keys for.
-     * @param deviceId - unique identifier for the device
-     *
-     * @returns device or null
-     * @deprecated Not supported for Rust Cryptography. Prefer {@link CryptoApi.getUserDeviceInfo}
-     */
-    getStoredDevice(userId: string, deviceId: string): DeviceInfo | null;
-    /**
-     * Mark the given device as verified
-     *
-     * @param userId - owner of the device
-     * @param deviceId - unique identifier for the device or user's
-     * cross-signing public key ID.
-     *
-     * @param verified - whether to mark the device as verified. defaults
-     *   to 'true'.
-     *
-     * @returns
-     *
-     * @remarks
-     * Fires {@link CryptoEvent#DeviceVerificationChanged}
-     */
-    setDeviceVerified(userId: string, deviceId: string, verified?: boolean): Promise<void>;
-    /**
-     * Mark the given device as blocked/unblocked
-     *
-     * @param userId - owner of the device
-     * @param deviceId - unique identifier for the device or user's
-     * cross-signing public key ID.
-     *
-     * @param blocked - whether to mark the device as blocked. defaults
-     *   to 'true'.
-     *
-     * @returns
-     *
-     * @remarks
-     * Fires {@link LegacyCryptoEvent.DeviceVerificationChanged}
-     *
-     * @deprecated Not supported for Rust Cryptography.
-     */
-    setDeviceBlocked(userId: string, deviceId: string, blocked?: boolean): Promise<void>;
-    /**
-     * Mark the given device as known/unknown
-     *
-     * @param userId - owner of the device
-     * @param deviceId - unique identifier for the device or user's
-     * cross-signing public key ID.
-     *
-     * @param known - whether to mark the device as known. defaults
-     *   to 'true'.
-     *
-     * @returns
-     *
-     * @remarks
-     * Fires {@link CryptoEvent#DeviceVerificationChanged}
-     *
-     * @deprecated Not supported for Rust Cryptography.
-     */
-    setDeviceKnown(userId: string, deviceId: string, known?: boolean): Promise<void>;
-    private setDeviceVerification;
-    /**
-     * Request a key verification from another user, using a DM.
-     *
-     * @param userId - the user to request verification with
-     * @param roomId - the room to use for verification
-     *
-     * @returns resolves to a VerificationRequest
-     *    when the request has been sent to the other party.
-     *
-     * @deprecated Not supported for Rust Cryptography. Prefer {@link CryptoApi.requestVerificationDM}.
-     */
-    requestVerificationDM(userId: string, roomId: string): Promise<VerificationRequest>;
-    /**
-     * Finds a DM verification request that is already in progress for the given room id
-     *
-     * @param roomId - the room to use for verification
-     *
-     * @returns the VerificationRequest that is in progress, if any
-     * @deprecated Not supported for Rust Cryptography. Prefer {@link CryptoApi.findVerificationRequestDMInProgress}.
-     */
-    findVerificationRequestDMInProgress(roomId: string): VerificationRequest | undefined;
-    /**
-     * Returns all to-device verification requests that are already in progress for the given user id
-     *
-     * @param userId - the ID of the user to query
-     *
-     * @returns the VerificationRequests that are in progress
-     * @deprecated Not supported for Rust Cryptography. Prefer {@link CryptoApi.getVerificationRequestsToDeviceInProgress}.
-     */
-    getVerificationRequestsToDeviceInProgress(userId: string): VerificationRequest[];
-    /**
-     * Request a key verification from another user.
-     *
-     * @param userId - the user to request verification with
-     * @param devices - array of device IDs to send requests to.  Defaults to
-     *    all devices owned by the user
-     *
-     * @returns resolves to a VerificationRequest
-     *    when the request has been sent to the other party.
-     *
-     * @deprecated Not supported for Rust Cryptography. Prefer {@link CryptoApi#requestOwnUserVerification} or {@link CryptoApi#requestDeviceVerification}.
-     */
-    requestVerification(userId: string, devices?: string[]): Promise<VerificationRequest>;
-    /**
-     * Begin a key verification.
-     *
-     * @param method - the verification method to use
-     * @param userId - the user to verify keys with
-     * @param deviceId - the device to verify
-     *
-     * @returns a verification object
-     * @deprecated Prefer {@link CryptoApi#requestOwnUserVerification} or {@link CryptoApi#requestDeviceVerification}.
-     */
-    beginKeyVerification(method: string, userId: string, deviceId: string): Verification<any, any>;
-    /**
-     * @deprecated Use {@link MatrixClient#secretStorage} and {@link SecretStorage.ServerSideSecretStorage#checkKey}.
-     */
-    checkSecretStorageKey(key: Uint8Array, info: SecretStorageKeyDescription): Promise<boolean>;
-    /**
-     * Set the global override for whether the client should ever send encrypted
-     * messages to unverified devices.  This provides the default for rooms which
-     * do not specify a value.
-     *
-     * @param value - whether to blacklist all unverified devices by default
-     *
-     * @deprecated Prefer direct access to {@link CryptoApi.globalBlacklistUnverifiedDevices}:
-     *
-     * ```javascript
-     * client.getCrypto().globalBlacklistUnverifiedDevices = value;
-     * ```
-     */
-    setGlobalBlacklistUnverifiedDevices(value: boolean): boolean;
-    /**
-     * @returns whether to blacklist all unverified devices by default
-     *
-     * @deprecated Prefer direct access to {@link CryptoApi.globalBlacklistUnverifiedDevices}:
-     *
-     * ```javascript
-     * value = client.getCrypto().globalBlacklistUnverifiedDevices;
-     * ```
-     */
-    getGlobalBlacklistUnverifiedDevices(): boolean;
-    /**
-     * Set whether sendMessage in a room with unknown and unverified devices
-     * should throw an error and not send them message. This has 'Global' for
-     * symmetry with setGlobalBlacklistUnverifiedDevices but there is currently
-     * no room-level equivalent for this setting.
-     *
-     * This API is currently UNSTABLE and may change or be removed without notice.
-     *
-     * It has no effect with the Rust crypto implementation.
-     *
-     * @param value - whether error on unknown devices
-     *
-     * ```ts
-     * client.getCrypto().globalErrorOnUnknownDevices = value;
-     * ```
-     */
-    setGlobalErrorOnUnknownDevices(value: boolean): void;
-    /**
-     * @returns whether to error on unknown devices
-     *
-     * This API is currently UNSTABLE and may change or be removed without notice.
-     */
-    getGlobalErrorOnUnknownDevices(): boolean;
-    /**
-     * Get the ID of one of the user's cross-signing keys
-     *
-     * @param type - The type of key to get the ID of.  One of
-     *     "master", "self_signing", or "user_signing".  Defaults to "master".
-     *
-     * @returns the key ID
-     * @deprecated Not supported for Rust Cryptography. prefer {@link Crypto.CryptoApi#getCrossSigningKeyId}
-     */
-    getCrossSigningId(type?: CrossSigningKey | string): string | null;
-    /**
-     * Get the cross signing information for a given user.
-     *
-     * The cross-signing API is currently UNSTABLE and may change without notice.
-     *
-     * @param userId - the user ID to get the cross-signing info for.
-     *
-     * @returns the cross signing information for the user.
-     * @deprecated Not supported for Rust Cryptography. Prefer {@link CryptoApi#userHasCrossSigningKeys}
-     */
-    getStoredCrossSigningForUser(userId: string): CrossSigningInfo | null;
-    /**
-     * Check whether a given user is trusted.
-     *
-     * The cross-signing API is currently UNSTABLE and may change without notice.
-     *
-     * @param userId - The ID of the user to check.
-     *
-     * @deprecated Use {@link Crypto.CryptoApi.getUserVerificationStatus | `CryptoApi.getUserVerificationStatus`}
-     */
-    checkUserTrust(userId: string): UserTrustLevel;
-    /**
-     * Check whether a given device is trusted.
-     *
-     * The cross-signing API is currently UNSTABLE and may change without notice.
-     *
-     * @param userId - The ID of the user whose devices is to be checked.
-     * @param deviceId - The ID of the device to check
-     *
-     * @deprecated Use {@link Crypto.CryptoApi.getDeviceVerificationStatus | `CryptoApi.getDeviceVerificationStatus`}
-     */
-    checkDeviceTrust(userId: string, deviceId: string): DeviceTrustLevel;
-    /**
-     * Check whether one of our own devices is cross-signed by our
-     * user's stored keys, regardless of whether we trust those keys yet.
-     *
-     * @param deviceId - The ID of the device to check
-     *
-     * @returns true if the device is cross-signed
-     *
-     * @deprecated Not supported for Rust Cryptography.
-     */
-    checkIfOwnDeviceCrossSigned(deviceId: string): boolean;
-    /**
-     * Check the copy of our cross-signing key that we have in the device list and
-     * see if we can get the private key. If so, mark it as trusted.
-     * @param opts - ICheckOwnCrossSigningTrustOpts object
-     *
-     * @deprecated Unneeded for the new crypto
-     */
-    checkOwnCrossSigningTrust(opts?: ICheckOwnCrossSigningTrustOpts): Promise<void>;
-    /**
-     * Checks that a given cross-signing private key matches a given public key.
-     * This can be used by the getCrossSigningKey callback to verify that the
-     * private key it is about to supply is the one that was requested.
-     * @param privateKey - The private key
-     * @param expectedPublicKey - The public key
-     * @returns true if the key matches, otherwise false
-     *
-     * @deprecated Not supported for Rust Cryptography.
-     */
-    checkCrossSigningPrivateKey(privateKey: Uint8Array, expectedPublicKey: string): boolean;
-    /**
-     * @deprecated Not supported for Rust Cryptography. Prefer {@link CryptoApi#requestDeviceVerification}.
-     */
-    legacyDeviceVerification(userId: string, deviceId: string, method: string): Promise<VerificationRequest>;
-    /**
-     * Perform any background tasks that can be done before a message is ready to
-     * send, in order to speed up sending of the message.
-     * @param room - the room the event is in
-     *
-     * @deprecated Prefer {@link CryptoApi.prepareToEncrypt | `CryptoApi.prepareToEncrypt`}:
-     *
-     * ```javascript
-     * client.getCrypto().prepareToEncrypt(room);
-     * ```
-     */
-    prepareToEncrypt(room: Room): void;
-    /**
-     * Checks if the user has previously published cross-signing keys
-     *
-     * This means downloading the devicelist for the user and checking if the list includes
-     * the cross-signing pseudo-device.
-     *
-     * @deprecated Prefer {@link CryptoApi.userHasCrossSigningKeys | `CryptoApi.userHasCrossSigningKeys`}:
-     *
-     * ```javascript
-     * result = client.getCrypto().userHasCrossSigningKeys();
-     * ```
-     */
-    userHasCrossSigningKeys(): Promise<boolean>;
-    /**
-     * Checks whether cross signing:
-     * - is enabled on this account and trusted by this device
-     * - has private keys either cached locally or stored in secret storage
-     *
-     * If this function returns false, bootstrapCrossSigning() can be used
-     * to fix things such that it returns true. That is to say, after
-     * bootstrapCrossSigning() completes successfully, this function should
-     * return true.
-     * @returns True if cross-signing is ready to be used on this device
-     * @deprecated Prefer {@link CryptoApi.isCrossSigningReady | `CryptoApi.isCrossSigningReady`}:
-     */
-    isCrossSigningReady(): Promise<boolean>;
-    /**
-     * Bootstrap cross-signing by creating keys if needed. If everything is already
-     * set up, then no changes are made, so this is safe to run to ensure
-     * cross-signing is ready for use.
-     *
-     * This function:
-     * - creates new cross-signing keys if they are not found locally cached nor in
-     *   secret storage (if it has been set up)
-     *
-     * @deprecated Prefer {@link CryptoApi.bootstrapCrossSigning | `CryptoApi.bootstrapCrossSigning`}.
-     */
-    bootstrapCrossSigning(opts: BootstrapCrossSigningOpts): Promise<void>;
-    /**
-     * Whether to trust a others users signatures of their devices.
-     * If false, devices will only be considered 'verified' if we have
-     * verified that device individually (effectively disabling cross-signing).
-     *
-     * Default: true
-     *
-     * @returns True if trusting cross-signed devices
-     *
-     * @deprecated Prefer {@link CryptoApi.getTrustCrossSignedDevices | `CryptoApi.getTrustCrossSignedDevices`}.
-     */
-    getCryptoTrustCrossSignedDevices(): boolean;
-    /**
-     * See getCryptoTrustCrossSignedDevices
-     *
-     * @param val - True to trust cross-signed devices
-     *
-     * @deprecated Prefer {@link CryptoApi.setTrustCrossSignedDevices | `CryptoApi.setTrustCrossSignedDevices`}.
-     */
-    setCryptoTrustCrossSignedDevices(val: boolean): void;
-    /**
-     * Counts the number of end to end session keys that are waiting to be backed up
-     * @returns Promise which resolves to the number of sessions requiring backup
-     *
-     * @deprecated Not supported for Rust Cryptography.
-     */
-    countSessionsNeedingBackup(): Promise<number>;
-    /**
-     * Get information about the encryption of an event
-     *
-     * @param event - event to be checked
-     * @returns The event information.
-     * @deprecated Prefer {@link Crypto.CryptoApi.getEncryptionInfoForEvent | `CryptoApi.getEncryptionInfoForEvent`}.
-     */
-    getEventEncryptionInfo(event: MatrixEvent): IEncryptedEventInfo;
-    /**
-     * Create a recovery key from a user-supplied passphrase.
-     *
-     * The Secure Secret Storage API is currently UNSTABLE and may change without notice.
-     *
-     * @param password - Passphrase string that can be entered by the user
-     *     when restoring the backup as an alternative to entering the recovery key.
-     *     Optional.
-     * @returns Object with public key metadata, encoded private
-     *     recovery key which should be disposed of after displaying to the user,
-     *     and raw private key to avoid round tripping if needed.
-     *
-     * @deprecated Prefer {@link CryptoApi.createRecoveryKeyFromPassphrase | `CryptoApi.createRecoveryKeyFromPassphrase`}.
-     */
-    createRecoveryKeyFromPassphrase(password?: string): Promise<IRecoveryKey>;
-    /**
-     * Checks whether secret storage:
-     * - is enabled on this account
-     * - is storing cross-signing private keys
-     * - is storing session backup key (if enabled)
-     *
-     * If this function returns false, bootstrapSecretStorage() can be used
-     * to fix things such that it returns true. That is to say, after
-     * bootstrapSecretStorage() completes successfully, this function should
-     * return true.
-     *
-     * @returns True if secret storage is ready to be used on this device
-     * @deprecated Prefer {@link CryptoApi.isSecretStorageReady | `CryptoApi.isSecretStorageReady`}.
-     */
-    isSecretStorageReady(): Promise<boolean>;
-    /**
-     * Bootstrap Secure Secret Storage if needed by creating a default key. If everything is
-     * already set up, then no changes are made, so this is safe to run to ensure secret
-     * storage is ready for use.
-     *
-     * This function
-     * - creates a new Secure Secret Storage key if no default key exists
-     *   - if a key backup exists, it is migrated to store the key in the Secret
-     *     Storage
-     * - creates a backup if none exists, and one is requested
-     * - migrates Secure Secret Storage to use the latest algorithm, if an outdated
-     *   algorithm is found
-     *
-     * @deprecated Use {@link CryptoApi.bootstrapSecretStorage | `CryptoApi.bootstrapSecretStorage`}.
-     */
-    bootstrapSecretStorage(opts: ICreateSecretStorageOpts): Promise<void>;
-    /**
-     * Add a key for encrypting secrets.
-     *
-     * The Secure Secret Storage API is currently UNSTABLE and may change without notice.
-     *
-     * @param algorithm - the algorithm used by the key
-     * @param opts - the options for the algorithm.  The properties used
-     *     depend on the algorithm given.
-     * @param keyName - the name of the key.  If not given, a random name will be generated.
-     *
-     * @returns An object with:
-     *     keyId: the ID of the key
-     *     keyInfo: details about the key (iv, mac, passphrase)
-     *
-     * @deprecated Use {@link MatrixClient#secretStorage} and {@link SecretStorage.ServerSideSecretStorage#addKey}.
-     */
-    addSecretStorageKey(algorithm: string, opts: AddSecretStorageKeyOpts, keyName?: string): Promise<{
-        keyId: string;
-        keyInfo: SecretStorageKeyDescription;
-    }>;
-    /**
-     * Check whether we have a key with a given ID.
-     *
-     * The Secure Secret Storage API is currently UNSTABLE and may change without notice.
-     *
-     * @param keyId - The ID of the key to check
-     *     for. Defaults to the default key ID if not provided.
-     * @returns Whether we have the key.
-     *
-     * @deprecated Use {@link MatrixClient#secretStorage} and {@link SecretStorage.ServerSideSecretStorage#hasKey}.
-     */
-    hasSecretStorageKey(keyId?: string): Promise<boolean>;
-    /**
-     * Store an encrypted secret on the server.
-     *
-     * The Secure Secret Storage API is currently UNSTABLE and may change without notice.
-     *
-     * @param name - The name of the secret
-     * @param secret - The secret contents.
-     * @param keys - The IDs of the keys to use to encrypt the secret or null/undefined
-     *     to use the default (will throw if no default key is set).
-     *
-     * @deprecated Use {@link MatrixClient#secretStorage} and {@link SecretStorage.ServerSideSecretStorage#store}.
-     */
-    storeSecret(name: string, secret: string, keys?: string[]): Promise<void>;
-    /**
-     * Get a secret from storage.
-     *
-     * The Secure Secret Storage API is currently UNSTABLE and may change without notice.
-     *
-     * @param name - the name of the secret
-     *
-     * @returns the contents of the secret
-     *
-     * @deprecated Use {@link MatrixClient#secretStorage} and {@link SecretStorage.ServerSideSecretStorage#get}.
-     */
-    getSecret(name: string): Promise<string | undefined>;
-    /**
-     * Check if a secret is stored on the server.
-     *
-     * The Secure Secret Storage API is currently UNSTABLE and may change without notice.
-     *
-     * @param name - the name of the secret
-     * @returns map of key name to key info the secret is encrypted
-     *     with, or null if it is not present or not encrypted with a trusted
-     *     key
-     *
-     * @deprecated Use {@link MatrixClient#secretStorage} and {@link SecretStorage.ServerSideSecretStorage#isStored}.
-     */
-    isSecretStored(name: string): Promise<Record<string, SecretStorageKeyDescription> | null>;
-    /**
-     * Request a secret from another device.
-     *
-     * The Secure Secret Storage API is currently UNSTABLE and may change without notice.
-     *
-     * @param name - the name of the secret to request
-     * @param devices - the devices to request the secret from
-     *
-     * @returns the secret request object
-     * @deprecated Not supported for Rust Cryptography.
-     */
-    requestSecret(name: string, devices: string[]): ISecretRequest;
-    /**
-     * Get the current default key ID for encrypting secrets.
-     *
-     * The Secure Secret Storage API is currently UNSTABLE and may change without notice.
-     *
-     * @returns The default key ID or null if no default key ID is set
-     *
-     * @deprecated Use {@link MatrixClient#secretStorage} and {@link SecretStorage.ServerSideSecretStorage#getDefaultKeyId}.
-     */
-    getDefaultSecretStorageKeyId(): Promise<string | null>;
-    /**
-     * Set the current default key ID for encrypting secrets.
-     *
-     * The Secure Secret Storage API is currently UNSTABLE and may change without notice.
-     *
-     * @param keyId - The new default key ID
-     *
-     * @deprecated Use {@link MatrixClient#secretStorage} and {@link SecretStorage.ServerSideSecretStorage#setDefaultKeyId}.
-     */
-    setDefaultSecretStorageKeyId(keyId: string): Promise<void>;
-    /**
-     * Checks that a given secret storage private key matches a given public key.
-     * This can be used by the getSecretStorageKey callback to verify that the
-     * private key it is about to supply is the one that was requested.
-     *
-     * The Secure Secret Storage API is currently UNSTABLE and may change without notice.
-     *
-     * @param privateKey - The private key
-     * @param expectedPublicKey - The public key
-     * @returns true if the key matches, otherwise false
-     *
-     * @deprecated The use of asymmetric keys for SSSS is deprecated.
-     *     Use {@link SecretStorage.ServerSideSecretStorage#checkKey} for symmetric keys.
-     */
-    checkSecretStoragePrivateKey(privateKey: Uint8Array, expectedPublicKey: string): boolean;
-    /**
-     * Get e2e information on the device that sent an event
-     *
-     * @param event - event to be checked
-     * @deprecated Not supported for Rust Cryptography.
-     */
-    getEventSenderDeviceInfo(event: MatrixEvent): Promise<DeviceInfo | null>;
-    /**
-     * Check if the sender of an event is verified
-     *
-     * @param event - event to be checked
-     *
-     * @returns true if the sender of this event has been verified using
-     * {@link MatrixClient#setDeviceVerified}.
-     *
-     * @deprecated Not supported for Rust Cryptography.
-     */
-    isEventSenderVerified(event: MatrixEvent): Promise<boolean>;
-    /**
-     * Get outgoing room key request for this event if there is one.
-     * @param event - The event to check for
-     *
-     * @returns A room key request, or null if there is none
-     *
-     * @deprecated Not supported for Rust Cryptography.
-     */
-    getOutgoingRoomKeyRequest(event: MatrixEvent): Promise<OutgoingRoomKeyRequest | null>;
-    /**
-     * Cancel a room key request for this event if one is ongoing and resend the
-     * request.
-     * @param event - event of which to cancel and resend the room
-     *                            key request.
-     * @returns A promise that will resolve when the key request is queued
-     *
-     * @deprecated Not supported for Rust Cryptography.
-     */
-    cancelAndResendEventRoomKeyRequest(event: MatrixEvent): Promise<void>;
-    /**
-     * Enable end-to-end encryption for a room. This does not modify room state.
-     * Any messages sent before the returned promise resolves will be sent unencrypted.
-     * @param roomId - The room ID to enable encryption in.
-     * @param config - The encryption config for the room.
-     * @returns A promise that will resolve when encryption is set up.
-     *
-     * @deprecated Not supported for Rust Cryptography. To enable encryption in a room, send an `m.room.encryption`
-     * state event.
-     */
-    setRoomEncryption(roomId: string, config: IRoomEncryption): Promise<void>;
-    /**
-     * Whether encryption is enabled for a room.
-     * @param roomId - the room id to query.
-     * @returns whether encryption is enabled.
-     *
-     * @deprecated Not correctly supported for Rust Cryptography. Use {@link CryptoApi.isEncryptionEnabledInRoom} and/or
-     *    {@link Room.hasEncryptionStateEvent}.
-     */
-    isRoomEncrypted(roomId: string): boolean;
-    /**
-     * Encrypts and sends a given object via Olm to-device messages to a given
-     * set of devices.
-     *
-     * @param userDeviceInfoArr - list of deviceInfo objects representing the devices to send to
-     *
-     * @param payload - fields to include in the encrypted payload
-     *
-     * @returns Promise which
-     *     resolves once the message has been encrypted and sent to the given
-     *     userDeviceMap, and returns the `{ contentMap, deviceInfoByDeviceId }`
-     *     of the successfully sent messages.
-     *
-     * @deprecated Instead use {@link CryptoApi.encryptToDeviceMessages} followed by {@link queueToDevice}.
-     */
-    encryptAndSendToDevices(userDeviceInfoArr: IOlmDevice<DeviceInfo>[], payload: object): Promise<void>;
-    /**
-     * Forces the current outbound group session to be discarded such
-     * that another one will be created next time an event is sent.
-     *
-     * @param roomId - The ID of the room to discard the session for
-     *
-     * @deprecated Prefer {@link CryptoApi.forceDiscardSession | `CryptoApi.forceDiscardSession`}:
-     */
-    forceDiscardSession(roomId: string): void;
-    /**
-     * Get a list containing all of the room keys
-     *
-     * This should be encrypted before returning it to the user.
-     *
-     * @returns a promise which resolves to a list of session export objects
-     *
-     * @deprecated Prefer {@link CryptoApi.exportRoomKeys | `CryptoApi.exportRoomKeys`}:
-     *
-     * ```javascript
-     * sessionData = await client.getCrypto().exportRoomKeys();
-     * ```
-     */
-    exportRoomKeys(): Promise<IMegolmSessionData[]>;
-    /**
-     * Import a list of room keys previously exported by exportRoomKeys
-     *
-     * @param keys - a list of session export objects
-     * @param opts - options object
-     *
-     * @returns a promise which resolves when the keys have been imported
-     *
-     * @deprecated Prefer {@link CryptoApi.importRoomKeys | `CryptoApi.importRoomKeys`}:
-     * ```javascript
-     *  await client.getCrypto()?.importRoomKeys([..]);
-     * ```
-     */
-    importRoomKeys(keys: IMegolmSessionData[], opts?: ImportRoomKeysOpts): Promise<void>;
-    /**
-     * Force a re-check of the local key backup status against
-     * what's on the server.
-     *
-     * @returns Object with backup info (as returned by
-     *     getKeyBackupVersion) in backupInfo and
-     *     trust information (as returned by isKeyBackupTrusted)
-     *     in trustInfo.
-     *
-     * @deprecated Prefer {@link Crypto.CryptoApi.checkKeyBackupAndEnable}.
-     */
-    checkKeyBackup(): Promise<IKeyBackupCheck | null>;
-    /**
-     * Get information about the current key backup from the server.
-     *
-     * Performs some basic validity checks on the shape of the result, and raises an error if it is not as expected.
-     *
-     * **Note**: there is no (supported) way to distinguish between "failure to talk to the server" and "another client
-     * uploaded a key backup version using an algorithm I don't understand.
-     *
-     * @returns Information object from API, or null if no backup is present on the server.
-     *
-     * @deprecated Prefer {@link CryptoApi.getKeyBackupInfo}.
-     */
-    getKeyBackupVersion(): Promise<IKeyBackupInfo | null>;
-    /**
-     * @param info - key backup info dict from getKeyBackupVersion()
-     *
-     * @deprecated Not supported for Rust Cryptography. Prefer {@link CryptoApi.isKeyBackupTrusted | `CryptoApi.isKeyBackupTrusted`}.
-     */
-    isKeyBackupTrusted(info: IKeyBackupInfo): Promise<TrustInfo>;
-    /**
-     * @returns true if the client is configured to back up keys to
-     *     the server, otherwise false. If we haven't completed a successful check
-     *     of key backup status yet, returns null.
-     *
-     * @deprecated Not supported for Rust Cryptography. Prefer direct access to {@link Crypto.CryptoApi.getActiveSessionBackupVersion}:
-     *
-     * ```javascript
-     * let enabled = (await client.getCrypto().getActiveSessionBackupVersion()) !== null;
-     * ```
-     */
-    getKeyBackupEnabled(): boolean | null;
-    /**
-     * Enable backing up of keys, using data previously returned from
-     * getKeyBackupVersion.
-     *
-     * @param info - Backup information object as returned by getKeyBackupVersion
-     * @returns Promise which resolves when complete.
-     *
-     * @deprecated Do not call this directly. Instead call {@link Crypto.CryptoApi.checkKeyBackupAndEnable}.
-     */
-    enableKeyBackup(info: IKeyBackupInfo): Promise<void>;
-    /**
-     * Disable backing up of keys.
-     *
-     * @deprecated Not supported for Rust Cryptography. It should be unnecessary to disable key backup.
-     */
-    disableKeyBackup(): void;
-    /**
-     * Set up the data required to create a new backup version.  The backup version
-     * will not be created and enabled until createKeyBackupVersion is called.
-     *
-     * @param password - Passphrase string that can be entered by the user
-     *     when restoring the backup as an alternative to entering the recovery key.
-     *     Optional.
-     *
-     * @returns Object that can be passed to createKeyBackupVersion and
-     *     additionally has a 'recovery_key' member with the user-facing recovery key string.
-     *
-     * @deprecated Not supported for Rust cryptography. Use {@link Crypto.CryptoApi.resetKeyBackup | `CryptoApi.resetKeyBackup`}.
-     */
-    prepareKeyBackupVersion(password?: string | Uint8Array | null, opts?: IKeyBackupPrepareOpts): Promise<Pick<IPreparedKeyBackupVersion, "algorithm" | "auth_data" | "recovery_key">>;
-    /**
-     * Check whether the key backup private key is stored in secret storage.
-     * @returns map of key name to key info the secret is
-     *     encrypted with, or null if it is not present or not encrypted with a
-     *     trusted key
-     */
-    isKeyBackupKeyStored(): Promise<Record<string, SecretStorageKeyDescription> | null>;
-    /**
-     * Create a new key backup version and enable it, using the information return
-     * from prepareKeyBackupVersion.
-     *
-     * @param info - Info object from prepareKeyBackupVersion
-     * @returns Object with 'version' param indicating the version created
-     *
-     * @deprecated Use {@link Crypto.CryptoApi.resetKeyBackup | `CryptoApi.resetKeyBackup`}.
-     */
-    createKeyBackupVersion(info: IKeyBackupInfo): Promise<IKeyBackupInfo>;
-    /**
-     * @deprecated Use {@link Crypto.CryptoApi.deleteKeyBackupVersion | `CryptoApi.deleteKeyBackupVersion`}.
-     */
-    deleteKeyBackupVersion(version: string): Promise<void>;
-    private makeKeyBackupPath;
-    /**
-     * Back up session keys to the homeserver.
-     * @param roomId - ID of the room that the keys are for Optional.
-     * @param sessionId - ID of the session that the keys are for Optional.
-     * @param version - backup version Optional.
-     * @param data - Object keys to send
-     * @returns a promise that will resolve when the keys
-     * are uploaded
-     *
-     * @deprecated Not supported for Rust Cryptography.
-     */
-    sendKeyBackup(roomId: undefined, sessionId: undefined, version: string | undefined, data: IKeyBackup): Promise<void>;
-    sendKeyBackup(roomId: string, sessionId: undefined, version: string | undefined, data: IKeyBackup): Promise<void>;
-    sendKeyBackup(roomId: string, sessionId: string, version: string | undefined, data: IKeyBackup): Promise<void>;
-    /**
-     * Marks all group sessions as needing to be backed up and schedules them to
-     * upload in the background as soon as possible.
-     *
-     * @deprecated Not supported for Rust Cryptography. This is done automatically as part of
-     * {@link CryptoApi.resetKeyBackup}, so there is probably no need to call this manually.
-     */
-    scheduleAllGroupSessionsForBackup(): Promise<void>;
-    /**
-     * Marks all group sessions as needing to be backed up without scheduling
-     * them to upload in the background.
-     *
-     * (This is done automatically as part of {@link CryptoApi.resetKeyBackup},
-     * so there is probably no need to call this manually.)
-     *
-     * @returns Promise which resolves to the number of sessions requiring a backup.
-     * @deprecated Not supported for Rust Cryptography.
-     */
-    flagAllGroupSessionsForBackup(): Promise<number>;
-    /**
-     * Return true if recovery key is valid.
-     * Try to decode the recovery key and check if it's successful.
-     * @param recoveryKey
-     * @deprecated Use {@link decodeRecoveryKey} directly
-     */
-    isValidRecoveryKey(recoveryKey: string): boolean;
-    /**
-     * Get the raw key for a key backup from the password
-     * Used when migrating key backups into SSSS
-     *
-     * The cross-signing API is currently UNSTABLE and may change without notice.
-     *
-     * @param password - Passphrase
-     * @param backupInfo - Backup metadata from `checkKeyBackup`
-     * @returns key backup key
-     * @deprecated Deriving a backup key from a passphrase is not part of the matrix spec. Instead, a random key is generated and stored/shared via 4S.
-     */
-    keyBackupKeyFromPassword(password: string, backupInfo: IKeyBackupInfo): Promise<Uint8Array>;
-    /**
-     * Get the raw key for a key backup from the recovery key
-     * Used when migrating key backups into SSSS
-     *
-     * The cross-signing API is currently UNSTABLE and may change without notice.
-     *
-     * @param recoveryKey - The recovery key
-     * @returns key backup key
-     * @deprecated Use {@link decodeRecoveryKey} directly
-     */
-    keyBackupKeyFromRecoveryKey(recoveryKey: string): Uint8Array;
-    /**
-     * Restore from an existing key backup via a passphrase.
-     *
-     * @param password - Passphrase
-     * @param targetRoomId - Room ID to target a specific room.
-     * Restores all rooms if omitted.
-     * @param targetSessionId - Session ID to target a specific session.
-     * Restores all sessions if omitted.
-     * @param backupInfo - Backup metadata from `getKeyBackupVersion` or `checkKeyBackup`.`backupInfo`
-     * @param opts - Optional params such as callbacks
-     * @returns Status of restoration with `total` and `imported`
-     * key counts.
-     *
-     * @deprecated Prefer {@link CryptoApi.restoreKeyBackupWithPassphrase | `CryptoApi.restoreKeyBackupWithPassphrase`}.
-     */
-    restoreKeyBackupWithPassword(password: string, targetRoomId: undefined, targetSessionId: undefined, backupInfo: IKeyBackupInfo, opts: IKeyBackupRestoreOpts): Promise<IKeyBackupRestoreResult>;
-    /**
-     * @deprecated Prefer {@link CryptoApi.restoreKeyBackupWithPassphrase | `CryptoApi.restoreKeyBackupWithPassphrase`}.
-     */
-    restoreKeyBackupWithPassword(password: string, targetRoomId: string, targetSessionId: undefined, backupInfo: IKeyBackupInfo, opts: IKeyBackupRestoreOpts): Promise<IKeyBackupRestoreResult>;
-    /**
-     * @deprecated Prefer {@link CryptoApi.restoreKeyBackupWithPassphrase | `CryptoApi.restoreKeyBackupWithPassphrase`}.
-     */
-    restoreKeyBackupWithPassword(password: string, targetRoomId: string, targetSessionId: string, backupInfo: IKeyBackupInfo, opts: IKeyBackupRestoreOpts): Promise<IKeyBackupRestoreResult>;
-    /**
-     * Restore from an existing key backup via a private key stored in secret
-     * storage.
-     *
-     * @param backupInfo - Backup metadata from `checkKeyBackup`
-     * @param targetRoomId - Room ID to target a specific room.
-     * Restores all rooms if omitted.
-     * @param targetSessionId - Session ID to target a specific session.
-     * Restores all sessions if omitted.
-     * @param opts - Optional params such as callbacks
-     * @returns Status of restoration with `total` and `imported`
-     * key counts.
-     *
-     * @deprecated Prefer {@link CryptoApi.restoreKeyBackup | `CryptoApi.restoreKeyBackup`}.
-     */
-    restoreKeyBackupWithSecretStorage(backupInfo: IKeyBackupInfo, targetRoomId?: string, targetSessionId?: string, opts?: IKeyBackupRestoreOpts): Promise<IKeyBackupRestoreResult>;
-    /**
-     * Restore from an existing key backup via an encoded recovery key.
-     *
-     * @param recoveryKey - Encoded recovery key
-     * @param targetRoomId - Room ID to target a specific room.
-     * Restores all rooms if omitted.
-     * @param targetSessionId - Session ID to target a specific session.
-     * Restores all sessions if omitted.
-     * @param backupInfo - Backup metadata from `checkKeyBackup`
-     * @param opts - Optional params such as callbacks
-
-     * @returns Status of restoration with `total` and `imported`
-     * key counts.
-     *
-     * @deprecated Prefer {@link CryptoApi.restoreKeyBackup | `CryptoApi.restoreKeyBackup`}.
-     */
-    restoreKeyBackupWithRecoveryKey(recoveryKey: string, targetRoomId: undefined, targetSessionId: undefined, backupInfo: IKeyBackupInfo, opts?: IKeyBackupRestoreOpts): Promise<IKeyBackupRestoreResult>;
-    /**
-     * @deprecated Prefer {@link CryptoApi.restoreKeyBackup | `CryptoApi.restoreKeyBackup`}.
-     */
-    restoreKeyBackupWithRecoveryKey(recoveryKey: string, targetRoomId: string, targetSessionId: undefined, backupInfo: IKeyBackupInfo, opts?: IKeyBackupRestoreOpts): Promise<IKeyBackupRestoreResult>;
-    /**
-     * @deprecated Prefer {@link CryptoApi.restoreKeyBackup | `CryptoApi.restoreKeyBackup`}.
-     */
-    restoreKeyBackupWithRecoveryKey(recoveryKey: string, targetRoomId: string, targetSessionId: string, backupInfo: IKeyBackupInfo, opts?: IKeyBackupRestoreOpts): Promise<IKeyBackupRestoreResult>;
-    /**
-     * Restore from an existing key backup via a private key stored locally
-     * @param targetRoomId
-     * @param targetSessionId
-     * @param backupInfo
-     * @param opts
-     *
-     * @deprecated Prefer {@link CryptoApi.restoreKeyBackup | `CryptoApi.restoreKeyBackup`}.
-     */
-    restoreKeyBackupWithCache(targetRoomId: undefined, targetSessionId: undefined, backupInfo: IKeyBackupInfo, opts?: IKeyBackupRestoreOpts): Promise<IKeyBackupRestoreResult>;
-    /**
-     * @deprecated Prefer {@link CryptoApi.restoreKeyBackup | `CryptoApi.restoreKeyBackup`}.
-     */
-    restoreKeyBackupWithCache(targetRoomId: string, targetSessionId: undefined, backupInfo: IKeyBackupInfo, opts?: IKeyBackupRestoreOpts): Promise<IKeyBackupRestoreResult>;
-    /**
-     * @deprecated Prefer {@link CryptoApi.restoreKeyBackup | `CryptoApi.restoreKeyBackup`}.
-     */
-    restoreKeyBackupWithCache(targetRoomId: string, targetSessionId: string, backupInfo: IKeyBackupInfo, opts?: IKeyBackupRestoreOpts): Promise<IKeyBackupRestoreResult>;
-    private restoreKeyBackup;
-    /**
-     * This method calculates the total number of keys present in the response of a `/room_keys/keys` call.
-     *
-     * @param res - The response from the server containing the keys to be counted.
-     *
-     * @returns The total number of keys in the backup.
-     */
-    private getTotalKeyCount;
-    /**
-     * This method handles the decryption of a full backup, i.e a call to `/room_keys/keys`.
-     * It will decrypt the keys in chunks and call the `block` callback for each chunk.
-     *
-     * @param res - The response from the server containing the keys to be decrypted.
-     * @param backupDecryptor - An instance of the BackupDecryptor class used to decrypt the keys.
-     * @param chunkSize - The size of the chunks to be processed at a time.
-     * @param block - A callback function that is called for each chunk of keys.
-     *
-     * @returns A promise that resolves when the decryption is complete.
-     */
-    private handleDecryptionOfAFullBackup;
-    deleteKeysFromBackup(roomId: undefined, sessionId: undefined, version?: string): Promise<void>;
-    deleteKeysFromBackup(roomId: string, sessionId: undefined, version?: string): Promise<void>;
-    deleteKeysFromBackup(roomId: string, sessionId: string, version?: string): Promise<void>;
     /**
      * Get the config for the media repository.
      * @returns Promise which resolves with an object containing the config.
@@ -2333,13 +1187,6 @@ export declare class MatrixClient extends TypedEventEmitter<EmittedEvents, Clien
      * @returns returns a promise which resolves with the result of the delayed send request
      */
     protected encryptAndSendEvent(room: Room | null, event: MatrixEvent, delayOpts: SendDelayedEventRequestOpts): Promise<SendDelayedEventResponse>;
-    private encryptEventIfNeeded;
-    /**
-     * Determine whether a given event should be encrypted when we send it to the given room.
-     *
-     * This takes into account event type and room configuration.
-     */
-    private shouldEncryptEventForRoom;
     /**
      * Returns the eventType that should be used taking encryption into account
      * for a given eventType.
@@ -2960,8 +1807,6 @@ export declare class MatrixClient extends TypedEventEmitter<EmittedEvents, Clien
      * @returns Rejects: with an error response.
      */
     getOpenIdToken(): Promise<IOpenIDToken>;
-    private startCallEventHandler;
-    private startMatrixRTC;
     /**
      * Once the client has been initialised, we want to clear notifications we
      * know for a fact should be here.
@@ -2973,24 +1818,6 @@ export declare class MatrixClient extends TypedEventEmitter<EmittedEvents, Clien
      * we have on record matches.
      */
     private fixupRoomNotifications;
-    /**
-     * @returns Promise which resolves: ITurnServerResponse object
-     * @returns Rejects: with an error response.
-     */
-    turnServer(): Promise<ITurnServerResponse>;
-    /**
-     * Get the TURN servers for this homeserver.
-     * @returns The servers or an empty list.
-     */
-    getTurnServers(): ITurnServer[];
-    /**
-     * Get the unix timestamp (in milliseconds) at which the current
-     * TURN credentials (from getTurnServers) expire
-     * @returns The expiry timestamp in milliseconds
-     */
-    getTurnServersExpiry(): number;
-    get pollingTurnServers(): boolean;
-    checkTurnServers(): Promise<boolean | undefined>;
     /**
      * Set whether to allow a fallback ICE server should be used for negotiating a
      * WebRTC connection if the homeserver doesn't provide any servers. Defaults to
@@ -3119,13 +1946,6 @@ export declare class MatrixClient extends TypedEventEmitter<EmittedEvents, Clien
         nextBatch?: string | null;
         prevBatch?: string | null;
     }>;
-    /**
-     * The app may wish to see if we have a key cached without
-     * triggering a user interaction.
-     *
-     * @deprecated Not supported for Rust Cryptography.
-     */
-    getCrossSigningCacheCallbacks(): ICacheCallbacks | undefined;
     /**
      * Generates a random string suitable for use as a client secret. <strong>This
      * method is experimental and may change.</strong>
@@ -3793,47 +2613,6 @@ export declare class MatrixClient extends TypedEventEmitter<EmittedEvents, Clien
         body: ISearchRequestBody;
         next_batch?: string;
     }, abortSignal?: AbortSignal): Promise<ISearchResponse>;
-    /**
-     * Upload keys
-     *
-     * @param content -  body of upload request
-     *
-     * @param opts - this method no longer takes any opts,
-     *  used to take opts.device_id but this was not removed from the spec as a redundant parameter
-     *
-     * @returns Promise which resolves: result object. Rejects: with
-     *     an error response ({@link MatrixError}).
-     */
-    uploadKeysRequest(content: IUploadKeysRequest, opts?: void): Promise<IKeysUploadResponse>;
-    uploadKeySignatures(content: KeySignatures): Promise<IUploadKeySignaturesResponse>;
-    /**
-     * Download device keys
-     *
-     * @param userIds -  list of users to get keys for
-     *
-     * @param token - sync token to pass in the query request, to help
-     *   the HS give the most recent results
-     *
-     * @returns Promise which resolves: result object. Rejects: with
-     *     an error response ({@link MatrixError}).
-     */
-    downloadKeysForUsers(userIds: string[], { token }?: {
-        token?: string;
-    }): Promise<IDownloadKeyResult>;
-    /**
-     * Claim one-time keys
-     *
-     * @param devices -  a list of [userId, deviceId] pairs
-     *
-     * @param keyAlgorithm -  desired key type
-     *
-     * @param timeout - the time (in milliseconds) to wait for keys from remote
-     *     servers
-     *
-     * @returns Promise which resolves: result object. Rejects: with
-     *     an error response ({@link MatrixError}).
-     */
-    claimOneTimeKeys(devices: [string, string][], keyAlgorithm?: string, timeout?: number): Promise<IClaimOTKsResult>;
     /**
      * Ask the server for a list of users who have changed their device lists
      * between a pair of sync tokens
@@ -3846,7 +2625,6 @@ export declare class MatrixClient extends TypedEventEmitter<EmittedEvents, Clien
         changed: string[];
         left: string[];
     }>;
-    uploadDeviceSigningKeys(auth?: AuthDict, keys?: CrossSigningKeys): Promise<{}>;
     /**
      * Register with an identity server using the OpenID token from the user's
      * Homeserver, which can be retrieved via