zapo-js 0.2.0 → 1.0.0

package/dist/media/{WaMediaTransferClient.js → transfer/WaMediaTransferClient.js}

@@ -1,46 +1,16 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WaMediaTransferClient = void 0;
-const node_stream_1 = require("node:stream");
-const constants_1 = require("./constants");
-const WaMediaCrypto_1 = require("./WaMediaCrypto");
-const constants_2 = require("../protocol/constants");
-const bytes_1 = require("../util/bytes");
-const primitives_1 = require("../util/primitives");
-const GOT_OPTIONAL_MODULE = 'got';
+const node_http_1 = __importDefault(require("node:http"));
+const node_https_1 = __importDefault(require("node:https"));
+const constants_1 = require("../constants");
+const WaMediaCrypto_1 = require("../crypto/WaMediaCrypto");
+const constants_2 = require("../../protocol/constants");
+const bytes_1 = require("../../util/bytes");
+const primitives_1 = require("../../util/primitives");
 function normalizeHeaderRecord(headers) {
     if (!headers) {
         return {};
@@ -51,56 +21,11 @@ function normalizeHeaderRecord(headers) {
     }
     return normalized;
 }
-function asOptionalGotModule(loaded) {
-    if (loaded && typeof loaded === 'object') {
-        const direct = loaded.stream;
-        if (typeof direct === 'function') {
-            return loaded;
-        }
-        const fallback = loaded.default;
-        if (fallback &&
-            typeof fallback === 'object' &&
-            'stream' in fallback &&
-            typeof fallback.stream === 'function') {
-            return fallback;
-        }
-        if (typeof fallback === 'function' && 'stream' in fallback) {
-            const maybeStream = fallback.stream;
-            if (typeof maybeStream === 'function') {
-                return fallback;
-            }
-        }
-    }
-    if (typeof loaded === 'function' && 'stream' in loaded) {
-        const maybeStream = loaded.stream;
-        if (typeof maybeStream === 'function') {
-            return loaded;
-        }
-    }
-    return null;
-}
-async function loadOptionalGotModule() {
-    try {
-        const loaded = await Promise.resolve(`${GOT_OPTIONAL_MODULE}`).then(s => __importStar(require(s)));
-        const module = asOptionalGotModule(loaded);
-        if (module) {
-            return module;
-        }
-        throw new Error('invalid got module export');
-    }
-    catch (error) {
-        const normalized = (0, primitives_1.toError)(error);
-        const code = normalized.code;
-        const message = normalized.message ?? '';
-        const isModuleNotFound = (code === 'ERR_MODULE_NOT_FOUND' || code === 'MODULE_NOT_FOUND') &&
-            (message.includes(`'${GOT_OPTIONAL_MODULE}'`) ||
-                message.includes(`"${GOT_OPTIONAL_MODULE}"`));
-        if (isModuleNotFound) {
-            throw new Error('optional dependency "got" is not installed. Install with: npm i got');
-        }
-        throw normalized;
-    }
-}
+/**
+ * Streaming media uploader/downloader. Handles host failover, encryption
+ * (`WaMediaCrypto`), and MAC verification. Used internally by the message
+ * coordinator and exposed for direct media transfer use cases.
+ */
 class WaMediaTransferClient {
     constructor(options = {}) {
         this.logger = options.logger;
@@ -108,31 +33,29 @@ class WaMediaTransferClient {
         this.defaultTimeoutMs = options.defaultTimeoutMs ?? constants_2.WA_DEFAULTS.MEDIA_TIMEOUT_MS;
         this.defaultMaxReadBytes = options.defaultMaxReadBytes;
         this.defaultHeaders = normalizeHeaderRecord(options.defaultHeaders);
-        this.defaultUploadDispatcher = options.defaultUploadDispatcher;
-        this.defaultDownloadDispatcher = options.defaultDownloadDispatcher;
         this.defaultUploadAgent = options.defaultUploadAgent;
         this.defaultDownloadAgent = options.defaultDownloadAgent;
-        this.gotModulePromise = null;
+        this.skipMacVerification = options.skipMacVerification === true;
     }
+    /**
+     * Streams an encrypted media payload from the first responsive media host.
+     * Returns the raw transfer response – caller is responsible for piping the body.
+     */
     async downloadStream(request) {
         const { urls, headers, timeoutMs } = this.resolveTransferRequest(request);
-        const dispatcher = request.dispatcher ?? this.defaultDownloadDispatcher;
         const agent = request.agent ?? this.defaultDownloadAgent;
         this.logger?.debug('media download stream start', {
             urls: urls.length,
             timeoutMs
         });
-        const result = await this.fetchWithFallback(urls, timeoutMs, request.signal, (url, signal) => this.transferRequest(url, {
-            method: 'GET',
-            headers,
-            signal
-        }, dispatcher, agent));
+        const result = await this.fetchWithFallback(urls, timeoutMs, request.signal, (url, signal) => this.httpRequest(url, { method: 'GET', headers, signal }, agent));
         this.logger?.trace('media download stream response', {
             url: result.url,
             status: result.status
         });
         return result;
     }
+    /** Convenience wrapper: downloads the encrypted body and returns it as a Uint8Array. */
     async downloadBytes(request) {
         const response = await this.downloadStream(request);
         await this.assertSuccessfulResponse(response);
@@ -143,6 +66,10 @@ class WaMediaTransferClient {
             maxBytes: request.maxBytes ?? this.defaultMaxReadBytes
         });
     }
+    /**
+     * Uploads a raw (already-encrypted or plaintext) body to the requested
+     * media URL. Returns the server's transfer response unchanged.
+     */
     async uploadStream(request) {
         const bodyIsBytes = request.body instanceof Uint8Array;
         const { urls, headers, timeoutMs } = this.resolveTransferRequest(request, {
@@ -151,7 +78,6 @@ class WaMediaTransferClient {
                 ? String(request.contentLength)
                 : undefined
         });
-        const dispatcher = request.dispatcher ?? this.defaultUploadDispatcher;
         const agent = request.agent ?? this.defaultUploadAgent;
         const uploadUrls = bodyIsBytes ? urls : urls.slice(0, 1);
         if (!bodyIsBytes && urls.length > 1) {
@@ -165,29 +91,18 @@ class WaMediaTransferClient {
             timeoutMs,
             method
         });
-        const result = await this.fetchWithFallback(uploadUrls, timeoutMs, request.signal, async (url, signal) => {
-            if (bodyIsBytes) {
-                return this.transferRequest(url, {
-                    method,
-                    headers,
-                    signal,
-                    body: request.body
-                }, dispatcher, agent);
-            }
-            return this.transferRequest(url, {
-                method,
-                headers,
-                signal,
-                body: request.body,
-                duplex: 'half'
-            }, dispatcher, agent);
-        });
+        const result = await this.fetchWithFallback(uploadUrls, timeoutMs, request.signal, (url, signal) => this.httpRequest(url, { method, headers, signal, body: request.body }, agent));
         this.logger?.trace('media upload stream response', {
             url: result.url,
             status: result.status
         });
         return result;
     }
+    /**
+     * Encrypts the plaintext body with the per-`mediaType` HKDF keys (a new
+     * media key is generated when none is supplied) and uploads it. Returns
+     * the upload response plus the derived key/hashes for the message stanza.
+     */
     async uploadEncrypted(request) {
         this.logger?.info('media encrypted upload start', {
             mediaType: request.mediaType
@@ -201,7 +116,6 @@ class WaMediaTransferClient {
                 directPath: request.directPath,
                 hosts: request.hosts,
                 headers: request.headers,
-                dispatcher: request.dispatcher,
                 agent: request.agent,
                 timeoutMs: request.timeoutMs,
                 signal: request.signal,
@@ -227,6 +141,10 @@ class WaMediaTransferClient {
             plaintextLength: metadata.plaintextLength
         };
     }
+    /**
+     * Downloads an encrypted media payload, decrypts it, and verifies the MAC
+     * + file SHA-256s. Returns the decrypted bytes.
+     */
     async downloadAndDecrypt(request) {
         this.logger?.info('media encrypted download start', {
             mediaType: request.mediaType
@@ -249,6 +167,11 @@ class WaMediaTransferClient {
             throw error;
         }
     }
+    /**
+     * Streaming variant of {@link downloadAndDecrypt}: returns a `plaintext`
+     * Readable plus a `metadata` promise that resolves after the stream ends
+     * with the verified hashes (or rejects on MAC/size failure).
+     */
     async downloadAndDecryptStream(request) {
         const response = await this.downloadStream(request);
         await this.assertSuccessfulResponse(response);
@@ -257,7 +180,8 @@ class WaMediaTransferClient {
             mediaType: request.mediaType,
             mediaKey: request.mediaKey,
             expectedFileSha256: request.fileSha256,
-            expectedFileEncSha256: request.fileEncSha256
+            expectedFileEncSha256: request.fileEncSha256,
+            skipMacVerification: this.skipMacVerification
         });
         decrypted.metadata.catch(() => undefined);
         this.logger?.debug('media encrypted download stream ready', {
@@ -268,125 +192,58 @@ class WaMediaTransferClient {
             metadata: decrypted.metadata
         };
     }
+    /** Drains a streaming response body to a Uint8Array (respects `maxBytes`). */
     async readResponseBytes(response, maxBytes) {
         if (!response.body) {
             return bytes_1.EMPTY_BYTES;
         }
         return (0, bytes_1.readAllBytes)(response.body, { maxBytes: maxBytes ?? this.defaultMaxReadBytes });
     }
-    async transferRequest(url, init, dispatcher, agent) {
-        if (agent) {
-            return this.gotWithAgent(url, init, agent);
-        }
-        return this.fetchWithDispatcher(url, init, dispatcher);
-    }
-    async fetchWithDispatcher(url, init, dispatcher) {
-        const response = !dispatcher
-            ? await fetch(url, init)
-            : await fetch(url, {
-                ...init,
-                dispatcher
-            });
-        return this.toFetchTransferResponse(response);
-    }
-    toFetchTransferResponse(response) {
-        return {
-            status: response.status,
-            ok: response.ok,
-            headers: Object.fromEntries(response.headers.entries()),
-            body: response.body
-                ? node_stream_1.Readable.fromWeb(response.body)
-                : null,
-            cancel: async () => {
-                if (!response.body) {
-                    return;
-                }
-                try {
-                    await response.body.cancel();
-                }
-                catch {
-                    // ignore cancel errors from remote resets
-                }
-            }
-        };
-    }
-    async gotWithAgent(url, init, agent) {
-        const got = await this.loadGotModule();
-        const urlObj = new URL(url);
-        const gotAgent = urlObj.protocol === 'http:'
-            ? { http: agent }
-            : urlObj.protocol === 'https:'
-                ? { https: agent }
-                : { http: agent, https: agent };
+    async httpRequest(url, init, agent) {
+        const parsed = new URL(url);
+        const transport = parsed.protocol === 'https:' ? node_https_1.default : node_http_1.default;
         return new Promise((resolve, reject) => {
-            const request = got.stream(url, {
-                method: init.method,
-                headers: (init.headers ?? {}),
-                body: init.body,
-                signal: init.signal,
-                throwHttpErrors: false,
-                retry: { limit: 0 },
-                agent: gotAgent
-            });
-            const onError = (error) => {
-                request.off('response', onResponse);
-                reject((0, primitives_1.toError)(error));
-            };
-            const onResponse = (incoming) => {
-                request.off('error', onError);
-                resolve(this.toGotTransferResponse(incoming));
-            };
-            request.once('error', onError);
-            request.once('response', onResponse);
-        });
-    }
-    async loadGotModule() {
-        if (!this.gotModulePromise) {
-            this.gotModulePromise = loadOptionalGotModule().catch((error) => {
-                this.gotModulePromise = null;
-                throw error;
-            });
-        }
-        return this.gotModulePromise;
-    }
-    toGotTransferResponse(incoming) {
-        if (!incoming || typeof incoming !== 'object') {
-            throw new Error('invalid got response object');
-        }
-        const stream = incoming;
-        const status = typeof stream.statusCode === 'number' &&
-            Number.isFinite(stream.statusCode) &&
-            stream.statusCode >= 100 &&
-            stream.statusCode <= 599
-            ? stream.statusCode
-            : 500;
-        const headers = {};
-        if (stream.headers && typeof stream.headers === 'object') {
-            const input = stream.headers;
-            for (const key in input) {
-                const value = input[key];
-                if (typeof value === 'string') {
-                    headers[key] = value;
-                    continue;
-                }
-                if (Array.isArray(value)) {
-                    headers[key] = value.join(', ');
-                    continue;
-                }
-                if (value !== undefined && value !== null) {
-                    headers[key] = String(value);
+            const req = transport.request(url, {
+                method: init.method ?? 'GET',
+                headers: init.headers,
+                signal: init.signal ?? undefined,
+                agent: agent ?? undefined
+            }, (res) => {
+                const status = res.statusCode ?? 500;
+                const headers = {};
+                for (const key in res.headers) {
+                    const value = res.headers[key];
+                    if (typeof value === 'string') {
+                        headers[key] = value;
+                    }
+                    else if (Array.isArray(value)) {
+                        headers[key] = value.join(', ');
+                    }
                 }
+                resolve({
+                    status,
+                    ok: status >= 200 && status < 300,
+                    headers,
+                    body: res,
+                    // eslint-disable-next-line @typescript-eslint/require-await
+                    cancel: async () => {
+                        res.destroy();
+                    }
+                });
+            });
+            req.on('error', (error) => reject((0, primitives_1.toError)(error)));
+            const body = init.body;
+            if (body instanceof Uint8Array) {
+                req.end(body);
             }
-        }
-        return {
-            status,
-            ok: status >= 200 && status < 300,
-            headers,
-            body: stream,
-            cancel: async () => {
-                stream.destroy();
+            else if (body) {
+                body.on('error', (err) => req.destroy((0, primitives_1.toError)(err)));
+                body.pipe(req);
             }
-        };
+            else {
+                req.end();
+            }
+        });
     }
     resolveTransferRequest(request, extraHeaders) {
         const headers = { ...this.defaultHeaders };
@@ -420,10 +277,11 @@ class WaMediaTransferClient {
                     fileEncSha256: encrypted.fileEncSha256,
                     plaintextLength: request.plaintext.byteLength
                 }),
+                // eslint-disable-next-line @typescript-eslint/require-await
                 cleanup: async () => undefined
             };
         }
-        const prepared = await WaMediaCrypto_1.WaMediaCrypto.encryptReadable(request.mediaType, mediaKey, request.plaintext);
+        const prepared = await WaMediaCrypto_1.WaMediaCrypto.encryptReadable(request.mediaType, mediaKey, request.plaintext, { expectedFileSize: request.contentLength ?? undefined });
         return {
             body: prepared.encrypted,
             contentLength: request.contentLength !== null && request.contentLength !== undefined

package/dist/media/{conn.js → transfer/conn.js}

@@ -1,9 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMediaConnResponse = parseMediaConnResponse;
-const constants_1 = require("../protocol/constants");
-const helpers_1 = require("../transport/node/helpers");
-const query_1 = require("../transport/node/query");
+const constants_1 = require("../../protocol/constants");
+const helpers_1 = require("../../transport/node/helpers");
+const query_1 = require("../../transport/node/query");
+const primitives_1 = require("../../util/primitives");
+/**
+ * Parses a `media_conn` IQ response into a {@link WaMediaConn} (auth token,
+ * absolute expiry, and host list). Throws on missing auth/ttl/hosts.
+ */
 function parseMediaConnResponse(node, nowMs) {
     (0, query_1.assertIqResult)(node, 'media_conn');
     const mediaConnNode = (0, helpers_1.findNodeChild)(node, constants_1.WA_NODE_TAGS.MEDIA_CONN);
@@ -14,8 +19,8 @@ function parseMediaConnResponse(node, nowMs) {
     if (!auth) {
         throw new Error('media_conn response is missing auth');
     }
-    const ttlRaw = Number.parseInt(mediaConnNode.attrs.ttl ?? '0', 10);
-    if (!Number.isFinite(ttlRaw) || ttlRaw <= 0) {
+    const ttlRaw = (0, primitives_1.parseOptionalInt)(mediaConnNode.attrs.ttl) ?? 0;
+    if (ttlRaw <= 0) {
         throw new Error('media_conn response has invalid ttl');
     }
     const expiresAtMs = ttlRaw >= 1000000000 ? ttlRaw * 1000 : nowMs + ttlRaw * 1000;

package/dist/message/WaMessageClient.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WaMessageClient = void 0;
-const ack_1 = require("./ack");
+const ack_1 = require("./primitives/ack");
 const constants_1 = require("../protocol/constants");
 const global_1 = require("../transport/node/builders/global");
 const async_1 = require("../util/async");
@@ -14,6 +14,11 @@ class MessagePublishNackError extends Error {
         this.retryable = retryable;
     }
 }
+/**
+ * Low-level message-publishing client. Sends pre-built message/receipt nodes,
+ * handles ack timeouts and retry on negative-ack failures, and is the
+ * transport hook used by {@link WaMessageCoordinator}.
+ */
 class WaMessageClient {
     constructor(options) {
         this.logger = options.logger;
@@ -23,6 +28,11 @@ class WaMessageClient {
         this.defaultMaxAttempts = options.defaultMaxAttempts ?? constants_1.WA_DEFAULTS.MESSAGE_MAX_ATTEMPTS;
         this.defaultRetryDelayMs = options.defaultRetryDelayMs ?? constants_1.WA_DEFAULTS.MESSAGE_RETRY_DELAY_MS;
     }
+    /**
+     * Publishes a `<message>` stanza and awaits its ack/receipt, retrying on
+     * retryable negative-ack errors up to `maxAttempts`. Returns the ack
+     * metadata extracted from the server response.
+     */
     async publishNode(node, options = {}) {
         if (node.tag !== constants_1.WA_MESSAGE_TAGS.MESSAGE) {
             throw new Error(`invalid node tag for message publish: ${node.tag}`);
@@ -54,14 +64,25 @@ class WaMessageClient {
                 if ((0, ack_1.isNegativeAckNode)(ackNode)) {
                     throw new MessagePublishNackError(`negative publish ack: ${(0, ack_1.describeAckNode)(ackNode)}`, (0, ack_1.isRetryableNegativeAck)(ackNode));
                 }
-                this.logger.info('message publish acknowledged', {
-                    id,
-                    tag: ackNode.tag,
-                    type: ackNode.attrs.type,
-                    phash: ackNode.attrs.phash,
-                    addressingMode: ackNode.attrs.addressing_mode,
-                    attempts: attempt
-                });
+                if (attempt > 1) {
+                    this.logger.info('message publish acknowledged after retry', {
+                        id,
+                        tag: ackNode.tag,
+                        type: ackNode.attrs.type,
+                        phash: ackNode.attrs.phash,
+                        addressingMode: ackNode.attrs.addressing_mode,
+                        attempts: attempt
+                    });
+                }
+                else {
+                    this.logger.trace('message publish acknowledged', {
+                        id,
+                        tag: ackNode.tag,
+                        type: ackNode.attrs.type,
+                        phash: ackNode.attrs.phash,
+                        addressingMode: ackNode.attrs.addressing_mode
+                    });
+                }
                 return {
                     id,
                     attempts: attempt,
@@ -74,25 +95,33 @@ class WaMessageClient {
                 const nackRetryable = error instanceof MessagePublishNackError ? error.retryable : false;
                 const canRetry = attempt < maxAttempts &&
                     (this.isRetryablePublishError(lastError) || nackRetryable);
+                if (canRetry) {
+                    this.logger.debug('message publish attempt failed, will retry', {
+                        attempt,
+                        maxAttempts,
+                        nackRetryable,
+                        message: lastError.message
+                    });
+                    await (0, async_1.delay)(retryDelayMs * attempt);
+                    continue;
+                }
                 this.logger.warn('message publish attempt failed', {
                     attempt,
                     maxAttempts,
-                    canRetry,
                     nackRetryable,
                     message: lastError.message
                 });
-                if (!canRetry) {
-                    throw lastError;
-                }
-                await (0, async_1.delay)(retryDelayMs * attempt);
+                throw lastError;
             }
         }
         throw lastError ?? new Error('message publish failed');
     }
+    /** Builds the encrypted message envelope from `input` and publishes it via {@link publishNode}. */
     async publishEncrypted(input, options = {}) {
         const node = this.buildEncryptedMessageNode(input);
         return this.publishNode(node, options);
     }
+    /** Fire-and-forget variant: sends a `<message>` stanza without awaiting an ack. */
     async sendMessageNode(node) {
         if (node.tag !== constants_1.WA_MESSAGE_TAGS.MESSAGE) {
             throw new Error(`invalid node tag for message send: ${node.tag}`);
@@ -104,6 +133,7 @@ class WaMessageClient {
         });
         await this.sendNode(node);
     }
+    /** Builds and sends an encrypted message envelope without awaiting an ack. */
     async sendEncrypted(input) {
         const node = this.buildEncryptedMessageNode(input);
         await this.sendMessageNode(node);
@@ -168,12 +198,13 @@ class WaMessageClient {
         };
         return node;
     }
+    /** Builds and sends a `<receipt>` stanza (delivery/read/played/etc.). */
     async sendReceipt(input) {
         const node = (0, global_1.buildReceiptNode)({
             kind: 'outbound',
             to: input.to,
             id: input.id,
-            type: input.type ?? 'read',
+            type: input.type ?? constants_1.WA_MESSAGE_TYPES.RECEIPT_TYPE_READ,
             participant: input.participant,
             recipient: input.recipient,
             category: input.category,

package/dist/message/addons/link-preview/builder.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildExtendedTextWithPreview = buildExtendedTextWithPreview;
+function buildExtendedTextWithPreview(text, resolved, thumbnailFields) {
+    const message = {
+        text,
+        matchedText: resolved.matchedText,
+        previewType: resolved.previewType
+    };
+    if (resolved.title !== undefined)
+        message.title = resolved.title;
+    if (resolved.description !== undefined)
+        message.description = resolved.description;
+    if (thumbnailFields.jpegThumbnail !== undefined) {
+        message.jpegThumbnail = thumbnailFields.jpegThumbnail;
+    }
+    if (thumbnailFields.thumbnailDirectPath !== undefined) {
+        message.thumbnailDirectPath = thumbnailFields.thumbnailDirectPath;
+    }
+    if (thumbnailFields.thumbnailSha256 !== undefined) {
+        message.thumbnailSha256 = thumbnailFields.thumbnailSha256;
+    }
+    if (thumbnailFields.thumbnailEncSha256 !== undefined) {
+        message.thumbnailEncSha256 = thumbnailFields.thumbnailEncSha256;
+    }
+    if (thumbnailFields.mediaKey !== undefined) {
+        message.mediaKey = thumbnailFields.mediaKey;
+    }
+    if (thumbnailFields.mediaKeyTimestamp !== undefined) {
+        message.mediaKeyTimestamp = thumbnailFields.mediaKeyTimestamp;
+    }
+    if (thumbnailFields.thumbnailWidth !== undefined) {
+        message.thumbnailWidth = thumbnailFields.thumbnailWidth;
+    }
+    if (thumbnailFields.thumbnailHeight !== undefined) {
+        message.thumbnailHeight = thumbnailFields.thumbnailHeight;
+    }
+    return { extendedTextMessage: message };
+}