@msssystems/mss-link-sdk 0.1.12 → 0.2.1

package/dist/client/browser-client.d.ts

@@ -0,0 +1,16 @@
+import { MssLinkClient, MssLinkClientOptions } from './mss-link-client';
+import { WasmCryptoEngine, WasmCryptoEngineOptions } from '../core/wasm-crypto-engine';
+import { MessagesCryptoClient } from '../modules/messages/messages-crypto.client';
+import { StorageCryptoClient } from '../modules/storage/storage-crypto.client';
+import { MediaCryptoClient } from '../modules/media/media-crypto.client';
+export interface BrowserClientOptions extends MssLinkClientOptions, Omit<WasmCryptoEngineOptions, 'apiBaseUrl' | 'accessToken'> {
+}
+export declare class BrowserMssLinkClient extends MssLinkClient {
+    readonly cryptoEngine: WasmCryptoEngine;
+    readonly messagesCrypto: MessagesCryptoClient;
+    readonly storageCrypto: StorageCryptoClient;
+    readonly mediaCrypto: MediaCryptoClient;
+    constructor(options: BrowserClientOptions);
+    setToken(token: string): Promise<void>;
+}
+export declare function createBrowserClient(options: BrowserClientOptions): BrowserMssLinkClient;

package/dist/client/browser-client.js

@@ -0,0 +1,35 @@
+import { MssLinkClient } from './mss-link-client';
+import { WasmCryptoEngine } from '../core/wasm-crypto-engine';
+import { MessagesCryptoClient } from '../modules/messages/messages-crypto.client';
+import { StorageCryptoClient } from '../modules/storage/storage-crypto.client';
+import { MediaCryptoClient } from '../modules/media/media-crypto.client';
+export class BrowserMssLinkClient extends MssLinkClient {
+    cryptoEngine;
+    messagesCrypto;
+    storageCrypto;
+    mediaCrypto;
+    constructor(options) {
+        super(options);
+        this.cryptoEngine = new WasmCryptoEngine({
+            userId: options.userId,
+            apiBaseUrl: options.baseUrl,
+            accessToken: typeof options.token === 'string' ? options.token : undefined,
+            deviceId: options.deviceId,
+            registrationId: options.registrationId,
+            signedPrekeyId: options.signedPrekeyId,
+            initialOneTimePrekeyCount: options.initialOneTimePrekeyCount,
+            minOneTimePrekeys: options.minOneTimePrekeys,
+            replenishOneTimePrekeys: options.replenishOneTimePrekeys,
+        });
+        this.messagesCrypto = new MessagesCryptoClient(this.cryptoEngine);
+        this.storageCrypto = new StorageCryptoClient(this.cryptoEngine);
+        this.mediaCrypto = new MediaCryptoClient(this.cryptoEngine);
+    }
+    async setToken(token) {
+        await super.setToken(token);
+        this.cryptoEngine.setAccessToken(token);
+    }
+}
+export function createBrowserClient(options) {
+    return new BrowserMssLinkClient(options);
+}

package/dist/client/index.d.ts

@@ -1,21 +1,4 @@
-export * from './api-base-url';
 export * from './client-options';
-export * from './decryption-errors';
-export * from './drive-file-runtime';
-export * from './drive-file-runtime.contracts';
-export * from './drive-key-wrapping';
-export * from './drive-key-wrapping.contracts';
-export * from './drive-sharing';
-export * from './drive-sharing.contracts';
-export * from './local-crypto-health';
-export * from './local-crypto-health.contracts';
-export * from './media-crypto.contracts';
-export * from './media-message.contracts';
-export * from './media-message-metadata';
-export * from './message.contracts';
-export * from './message-decryption.contracts';
-export * from './message-decryption-state';
-export * from './message.mapper';
-export * from './mss-link-browser-client';
-export * from './storage-metadata-crypto';
-export * from './storage-metadata-crypto.contracts';
+export * from './mss-link-client';
+export * from './browser-client';
+export * from './wasm-client.types';

package/dist/client/index.js

@@ -1,21 +1,4 @@
-export * from './api-base-url';
 export * from './client-options';
-export * from './decryption-errors';
-export * from './drive-file-runtime';
-export * from './drive-file-runtime.contracts';
-export * from './drive-key-wrapping';
-export * from './drive-key-wrapping.contracts';
-export * from './drive-sharing';
-export * from './drive-sharing.contracts';
-export * from './local-crypto-health';
-export * from './local-crypto-health.contracts';
-export * from './media-crypto.contracts';
-export * from './media-message.contracts';
-export * from './media-message-metadata';
-export * from './message.contracts';
-export * from './message-decryption.contracts';
-export * from './message-decryption-state';
-export * from './message.mapper';
-export * from './mss-link-browser-client';
-export * from './storage-metadata-crypto';
-export * from './storage-metadata-crypto.contracts';
+export * from './mss-link-client';
+export * from './browser-client';
+export * from './wasm-client.types';

package/dist/client/mss-link-client.d.ts

@@ -0,0 +1,12 @@
+import { HttpClient, HttpClientOptions } from '../core/http-client';
+import { ChatsClient } from '../modules/chats/chats.client';
+import { MessagesClient } from '../modules/messages/messages.client';
+export interface MssLinkClientOptions extends HttpClientOptions {
+}
+export declare class MssLinkClient {
+    readonly http: HttpClient;
+    readonly chats: ChatsClient;
+    readonly messages: MessagesClient;
+    constructor(options: MssLinkClientOptions);
+    setToken(token: string): Promise<void>;
+}

package/dist/client/mss-link-client.js

@@ -0,0 +1,17 @@
+import { HttpClient } from '../core/http-client';
+import { ChatsClient } from '../modules/chats/chats.client';
+import { MessagesClient } from '../modules/messages/messages.client';
+export class MssLinkClient {
+    http;
+    chats;
+    messages;
+    constructor(options) {
+        this.http = new HttpClient(options);
+        // Initialize all modules
+        this.chats = new ChatsClient(this.http);
+        this.messages = new MessagesClient(this.http);
+    }
+    async setToken(token) {
+        await this.http.setToken(token);
+    }
+}

package/dist/client/wasm-client.types.d.ts

@@ -1,5 +1,5 @@
 import type { WasmMssClient } from '@msssystems/mss-crypto-wasm';
-import type { WasmEncryptedMediaBytes } from './media-crypto.contracts';
+import type { WasmEncryptedMediaBytes } from '../modules/media/media-crypto.contracts';
 export interface MssLinkWasmClient extends WasmMssClient {
     sendMediaMessage(chatId: string, targetUserId: string, metadataJson: string, mediaAssetIds: string[]): Promise<string>;
 }

package/dist/contracts/chat.contract.d.ts

@@ -0,0 +1,189 @@
+import type { MediaMessageAttachmentInput, MediaMessageAttachmentMetadata } from '../modules/media/media-message.contracts';
+import type { DecryptedMessage } from '../modules/messages/message.contracts';
+export type MessageStatus = 'SENT' | 'DELIVERED' | 'READ';
+export interface MessageReceiptSummary {
+    total: number;
+    sent: number;
+    delivered: number;
+    read: number;
+}
+export interface MessageMediaAttachment {
+    id: string;
+    assetId: string;
+    mimeType: string;
+    size: string;
+    status: 'ATTACHED';
+    uploadedAt: string;
+}
+export interface ChatMember {
+    id: string;
+    role: 'MEMBER' | 'ADMIN';
+    archivedAt?: string | null;
+    hiddenAt?: string | null;
+    lastReadAt?: string | null;
+    user: {
+        id: string;
+        username: string;
+        displayName: string;
+        avatarUrl?: string | null;
+    };
+}
+export interface Chat {
+    id: string;
+    type: 'DIRECT' | 'GROUP';
+    name?: string | null;
+    avatarUrl?: string | null;
+    members: ChatMember[];
+    messages?: Array<{
+        id: string;
+        ciphertext: string;
+        senderId: string;
+        createdAt: string;
+    }>;
+    myArchivedAt?: string | null;
+    myHiddenAt?: string | null;
+    myLastReadAt?: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface Message {
+    id: string;
+    type: string;
+    status: MessageStatus;
+    myReceiptStatus?: MessageStatus | null;
+    receiptSummary: MessageReceiptSummary;
+    clientMessageId?: string | null;
+    ciphertext: string;
+    chatId: string;
+    senderId: string;
+    sender: {
+        id: string;
+        displayName: string;
+        avatarUrl?: string | null;
+    };
+    media: MessageMediaAttachment[];
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CreateMediaUploadInput {
+    originalName: string;
+    mimeType: string;
+    size: number;
+}
+export interface MediaUploadInitResponse {
+    assetId: string;
+    uploadUrl: string;
+    metadata: Record<string, string>;
+}
+export interface MediaAssetUrlResponse {
+    assetId: string;
+    url: string;
+}
+export interface MediaAssetBlobResponse {
+    blob: Blob;
+    fileName: string;
+}
+export interface MessagesResponse {
+    messages: Message[];
+    nextCursor?: string | null;
+}
+export interface SyncCheckpoint {
+    lastAckedSequence: string;
+    acknowledgedAt: string;
+}
+export interface AckSyncInput {
+    sequence: string;
+}
+export interface MarkMessagesStatusInput {
+    chatId: string;
+    throughMessageId?: string;
+    limit?: number;
+}
+export type SyncEventType = 'MESSAGE_NEW' | 'MESSAGE_STATUS_UPDATED';
+export interface SyncEvent {
+    sequence: string;
+    type: SyncEventType;
+    chatId: string;
+    messageId?: string | null;
+    messageStatus?: MessageStatus | null;
+    message?: Message | null;
+    createdAt: string;
+}
+export interface SyncEventsResponse {
+    events: SyncEvent[];
+    nextCursor?: string | null;
+}
+export interface SyncEventsInput {
+    cursor?: string | null;
+    limit?: number;
+}
+export interface SyncClientInput {
+    profileId: string;
+    accessToken: string;
+}
+export interface ChatMessagesPageInput {
+    chatId: string;
+    before?: string;
+    after?: string;
+    limit?: number;
+}
+export interface CreateDirectChatInput {
+    targetUserId: string;
+}
+export interface CreateGroupChatInput {
+    name: string;
+    memberUserIds: string[];
+}
+export interface DecryptedMessagesInput {
+    profileId: string;
+    accessToken: string;
+    chatId: string;
+}
+export interface SendEncryptedMessageInput {
+    profileId: string;
+    accessToken: string;
+    chatId: string;
+    targetUserId: string;
+    text: string;
+}
+export interface SendMediaMessageInput {
+    profileId: string;
+    accessToken: string;
+    chatId: string;
+    targetUserId: string;
+    attachments: MediaMessageAttachmentInput[];
+    caption?: string;
+}
+export interface EncryptMediaAssetInput {
+    profileId: string;
+    accessToken: string;
+    assetId: string;
+    file: Blob;
+    mimeType: string;
+    size: string | number;
+    originalName?: string;
+    uploadedAt?: string;
+}
+export interface DecryptMediaAssetInput {
+    profileId: string;
+    accessToken: string;
+    encryptedBlob: Blob;
+    metadata: MediaMessageAttachmentMetadata;
+}
+export interface UploadAndSendMediaMessageInput {
+    profileId: string;
+    accessToken: string;
+    chatId: string;
+    targetUserId: string;
+    file: File;
+    caption?: string;
+    onLifecycleChange?: (event: MediaUploadLifecycleEvent) => void;
+}
+export type MediaUploadLifecycleStatus = 'uploading' | 'uploaded' | 'attached' | 'failed';
+export interface MediaUploadLifecycleEvent {
+    status: MediaUploadLifecycleStatus;
+    assetId?: string;
+    errorMessage?: string;
+}
+export type { DecryptedMessage };
+export type { MediaMessageAttachmentMetadata };

package/dist/contracts/user-search.contract.d.ts

@@ -0,0 +1,9 @@
+export interface SearchUserResult {
+    id: string;
+    username: string;
+    displayName: string;
+    avatarUrl: string | null;
+}
+export interface SearchUsersResponse {
+    users: SearchUserResult[];
+}

package/dist/core/http-client.d.ts

@@ -0,0 +1,24 @@
+export interface HttpClientOptions {
+    baseUrl: string;
+    token?: string | (() => string | Promise<string>);
+    fetch?: typeof fetch;
+}
+export declare class HttpClient {
+    private baseUrl;
+    private token?;
+    private customFetch;
+    constructor(options: HttpClientOptions);
+    setToken(token: string): Promise<void>;
+    private getHeaders;
+    request<T>(method: string, path: string, options?: {
+        body?: any;
+        params?: Record<string, any>;
+        headers?: Record<string, string>;
+        responseType?: 'json' | 'blob';
+    }): Promise<T>;
+    get<T>(path: string, options?: Omit<Parameters<typeof this.request>[2], 'body'>): Promise<T>;
+    post<T>(path: string, body?: any, options?: Omit<Parameters<typeof this.request>[2], 'body'>): Promise<T>;
+    put<T>(path: string, body?: any, options?: Omit<Parameters<typeof this.request>[2], 'body'>): Promise<T>;
+    patch<T>(path: string, body?: any, options?: Omit<Parameters<typeof this.request>[2], 'body'>): Promise<T>;
+    delete<T>(path: string, options?: Omit<Parameters<typeof this.request>[2], 'body'>): Promise<T>;
+}

package/dist/core/http-client.js

@@ -0,0 +1,80 @@
+import { ApiError } from '../errors/api-error';
+export class HttpClient {
+    baseUrl;
+    token;
+    customFetch;
+    constructor(options) {
+        this.baseUrl = options.baseUrl.replace(/\/$/, '');
+        this.token = options.token;
+        // Fallback to global fetch if not provided
+        this.customFetch = options.fetch ?? (typeof globalThis !== 'undefined' ? globalThis.fetch.bind(globalThis) : fetch);
+    }
+    async setToken(token) {
+        this.token = token;
+    }
+    async getHeaders(customHeaders) {
+        const headers = {
+            'Content-Type': 'application/json',
+            ...customHeaders,
+        };
+        if (this.token) {
+            const tokenStr = typeof this.token === 'function' ? await this.token() : this.token;
+            if (tokenStr) {
+                headers['Authorization'] = `Bearer ${tokenStr}`;
+            }
+        }
+        return headers;
+    }
+    async request(method, path, options = {}) {
+        const url = new URL(`${this.baseUrl}${path}`);
+        if (options.params) {
+            for (const [key, value] of Object.entries(options.params)) {
+                if (value !== undefined && value !== null) {
+                    url.searchParams.append(key, String(value));
+                }
+            }
+        }
+        const headers = await this.getHeaders(options.headers);
+        const fetchOptions = {
+            method,
+            headers,
+        };
+        if (options.body) {
+            fetchOptions.body = JSON.stringify(options.body);
+        }
+        const response = await this.customFetch(url.toString(), fetchOptions);
+        if (!response.ok) {
+            let errorPayload;
+            try {
+                errorPayload = await response.json();
+            }
+            catch {
+                errorPayload = { message: response.statusText };
+            }
+            throw new ApiError(response.status, errorPayload.message || 'API request failed', errorPayload);
+        }
+        if (options.responseType === 'blob') {
+            return response.blob();
+        }
+        // Handle empty responses
+        if (response.status === 204 || response.headers.get('content-length') === '0') {
+            return null;
+        }
+        return response.json();
+    }
+    get(path, options) {
+        return this.request('GET', path, options);
+    }
+    post(path, body, options) {
+        return this.request('POST', path, { ...options, body });
+    }
+    put(path, body, options) {
+        return this.request('PUT', path, { ...options, body });
+    }
+    patch(path, body, options) {
+        return this.request('PATCH', path, { ...options, body });
+    }
+    delete(path, options) {
+        return this.request('DELETE', path, options);
+    }
+}

package/dist/{client → core}/local-crypto-health.contracts.d.ts

@@ -1,4 +1,4 @@
-import type { LocalCryptoErrorCode } from './decryption-errors';
+import type { LocalCryptoErrorCode } from '../errors/decryption-errors';
 export type LocalCryptoHealthStatus = 'ready' | 'recovery_required' | 'corrupt' | 'unavailable';
 export type LocalCryptoHealthErrorCode = LocalCryptoErrorCode;
 export interface LocalCryptoHealth {

package/dist/{client → core}/local-crypto-health.js

@@ -1,4 +1,4 @@
-import { normalizeLocalCryptoError } from './decryption-errors';
+import { normalizeLocalCryptoError } from '../errors/decryption-errors';
 export async function checkLocalCryptoHealth(checkReady) {
     try {
         await checkReady();

package/dist/core/wasm-crypto-engine.d.ts

@@ -0,0 +1,34 @@
+import { WasmCallQueue } from './wasm-call-queue';
+import type { MssCryptoWasmModule, WasmMssClientInstance } from '../client/wasm-client.types';
+export interface WasmCryptoEngineOptions {
+    userId: string;
+    apiBaseUrl: string;
+    accessToken?: string | undefined;
+    deviceId?: number | undefined;
+    registrationId?: number | undefined;
+    signedPrekeyId?: number | undefined;
+    initialOneTimePrekeyCount?: number | undefined;
+    minOneTimePrekeys?: number | undefined;
+    replenishOneTimePrekeys?: number | undefined;
+}
+export declare class WasmCryptoEngine {
+    private readonly userId;
+    private readonly apiBaseUrl;
+    private readonly deviceId;
+    private readonly registrationId;
+    private readonly signedPrekeyId;
+    private readonly initialOneTimePrekeyCount;
+    private readonly minOneTimePrekeys;
+    private readonly replenishOneTimePrekeys;
+    readonly queue: WasmCallQueue;
+    private wasmClient;
+    private wasmModulePromise;
+    private accessToken;
+    constructor(options: WasmCryptoEngineOptions);
+    setAccessToken(accessToken: string | null): void;
+    ensureReady(): Promise<void>;
+    reset(): void;
+    runWithClient<T>(callback: (client: WasmMssClientInstance) => Promise<T>): Promise<T>;
+    getClient(): Promise<WasmMssClientInstance>;
+    loadWasmModule(): Promise<MssCryptoWasmModule>;
+}

package/dist/core/wasm-crypto-engine.js

@@ -0,0 +1,75 @@
+import { normalizeProductApiBaseUrl } from './api-base-url';
+import { normalizeLocalCryptoError } from '../errors/decryption-errors';
+import { WasmCallQueue } from './wasm-call-queue';
+const DEFAULT_DEVICE_ID = 1;
+const DEFAULT_REGISTRATION_ID = 1;
+const DEFAULT_SIGNED_PREKEY_ID = 1;
+const DEFAULT_ONE_TIME_PREKEY_COUNT = 10;
+const DEFAULT_MIN_ONE_TIME_PREKEYS = 5;
+const DEFAULT_REPLENISH_ONE_TIME_PREKEYS = 10;
+export class WasmCryptoEngine {
+    userId;
+    apiBaseUrl;
+    deviceId;
+    registrationId;
+    signedPrekeyId;
+    initialOneTimePrekeyCount;
+    minOneTimePrekeys;
+    replenishOneTimePrekeys;
+    queue = new WasmCallQueue();
+    wasmClient = null;
+    wasmModulePromise = null;
+    accessToken;
+    constructor(options) {
+        this.userId = options.userId;
+        this.apiBaseUrl = normalizeProductApiBaseUrl(options.apiBaseUrl);
+        this.accessToken = options.accessToken ?? null;
+        this.deviceId = options.deviceId ?? DEFAULT_DEVICE_ID;
+        this.registrationId = options.registrationId ?? DEFAULT_REGISTRATION_ID;
+        this.signedPrekeyId = options.signedPrekeyId ?? DEFAULT_SIGNED_PREKEY_ID;
+        this.initialOneTimePrekeyCount =
+            options.initialOneTimePrekeyCount ?? DEFAULT_ONE_TIME_PREKEY_COUNT;
+        this.minOneTimePrekeys =
+            options.minOneTimePrekeys ?? DEFAULT_MIN_ONE_TIME_PREKEYS;
+        this.replenishOneTimePrekeys =
+            options.replenishOneTimePrekeys ?? DEFAULT_REPLENISH_ONE_TIME_PREKEYS;
+    }
+    setAccessToken(accessToken) {
+        this.accessToken = accessToken;
+        this.wasmClient?.setAccessToken(accessToken);
+    }
+    async ensureReady() {
+        try {
+            await this.runWithClient(async (client) => {
+                await client.ensureDeviceRegistered(this.registrationId, this.signedPrekeyId, this.initialOneTimePrekeyCount);
+                await client.replenishOneTimePreKeys(this.minOneTimePrekeys, this.replenishOneTimePrekeys);
+            });
+        }
+        catch (error) {
+            throw normalizeLocalCryptoError(error);
+        }
+    }
+    reset() {
+        this.wasmClient?.free();
+        this.wasmClient = null;
+        this.wasmModulePromise = null;
+    }
+    async runWithClient(callback) {
+        return this.queue.run(async () => callback(await this.getClient()));
+    }
+    async getClient() {
+        if (typeof window === 'undefined') {
+            throw new Error('MSS Link browser client is available only in browser context.');
+        }
+        if (!this.wasmClient) {
+            const sdkModule = await this.loadWasmModule();
+            this.wasmClient = new sdkModule.WasmMssClient(this.userId, this.deviceId, this.apiBaseUrl);
+            this.wasmClient.setAccessToken(this.accessToken);
+        }
+        return this.wasmClient;
+    }
+    loadWasmModule() {
+        this.wasmModulePromise ??= import('@msssystems/mss-crypto-wasm').then((module) => module);
+        return this.wasmModulePromise;
+    }
+}

package/dist/errors/api-error.d.ts

@@ -0,0 +1,6 @@
+import { SdkError } from './sdk-error';
+export declare class ApiError extends SdkError {
+    readonly status: number;
+    readonly payload?: any | undefined;
+    constructor(status: number, message: string, payload?: any | undefined);
+}

package/dist/errors/api-error.js

@@ -0,0 +1,11 @@
+import { SdkError } from './sdk-error';
+export class ApiError extends SdkError {
+    status;
+    payload;
+    constructor(status, message, payload) {
+        super(`[HTTP ${status}] ${message}`);
+        this.status = status;
+        this.payload = payload;
+        this.name = 'ApiError';
+    }
+}

package/dist/errors/sdk-error.d.ts

@@ -0,0 +1,3 @@
+export declare class SdkError extends Error {
+    constructor(message: string);
+}

package/dist/errors/sdk-error.js

@@ -0,0 +1,6 @@
+export class SdkError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'SdkError';
+    }
+}

package/dist/modules/chats/chats.client.d.ts

@@ -0,0 +1,11 @@
+import { HttpClient } from '../../core/http-client';
+export declare class ChatsClient {
+    private readonly http;
+    constructor(http: HttpClient);
+    list(): Promise<any[]>;
+    getDetails(chatId: string): Promise<any>;
+    createDirect(targetUserId: string): Promise<any>;
+    createGroup(name: string, userIds: string[]): Promise<any>;
+    archive(chatId: string): Promise<any>;
+    hide(chatId: string): Promise<any>;
+}

package/dist/modules/chats/chats.client.js

@@ -0,0 +1,25 @@
+// TODO: Import proper types from contracts
+export class ChatsClient {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    async list() {
+        return this.http.get('/link/v1/chats');
+    }
+    async getDetails(chatId) {
+        return this.http.get(`/link/v1/chats/${chatId}`);
+    }
+    async createDirect(targetUserId) {
+        return this.http.post('/link/v1/chats/direct', { targetUserId });
+    }
+    async createGroup(name, userIds) {
+        return this.http.post('/link/v1/chats/group', { name, userIds });
+    }
+    async archive(chatId) {
+        return this.http.post(`/link/v1/chats/${chatId}/archive`);
+    }
+    async hide(chatId) {
+        return this.http.post(`/link/v1/chats/${chatId}/hide`);
+    }
+}

package/dist/modules/media/media-crypto.client.d.ts

@@ -0,0 +1,10 @@
+import { WasmCryptoEngine } from '../../core/wasm-crypto-engine';
+import type { DecryptMediaBlobInput, DecryptedMediaBlobResult, EncryptedMediaBlobResult, EncryptMediaBlobInput } from './media-crypto.contracts';
+import type { SendMediaMessageParams } from './media-message.contracts';
+export declare class MediaCryptoClient {
+    private readonly engine;
+    constructor(engine: WasmCryptoEngine);
+    sendMediaMessage(params: SendMediaMessageParams): Promise<string>;
+    encryptMediaBlob(input: EncryptMediaBlobInput): Promise<EncryptedMediaBlobResult>;
+    decryptMediaBlob(input: DecryptMediaBlobInput): Promise<DecryptedMediaBlobResult>;
+}