@azure/communication-chat 1.5.0-beta.2 → 1.6.0-beta.1

package/dist/index.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var tslib = require('tslib');
 var communicationCommon = require('@azure/communication-common');
 var logger$1 = require('@azure/logger');
+var abortController = require('@azure/abort-controller');
 var coreRestPipeline = require('@azure/core-rest-pipeline');
 var coreTracing = require('@azure/core-tracing');
 var coreClient = require('@azure/core-client');
@@ -55,6 +56,41 @@ const mapToAddChatParticipantsRequestRestModel = (addParticipantsRequest) => {
         participants: (_a = addParticipantsRequest.participants) === null || _a === void 0 ? void 0 : _a.map((participant) => mapToChatParticipantRestModel(participant)),
     };
 };
+/**
+ * @internal
+ * Mapping chat attachment SDK model to chat attachment REST model
+ */
+const mapToChatAttachmentRestModel = (chatAttachment) => {
+    const { attachmentType } = chatAttachment, rest = tslib.__rest(chatAttachment, ["attachmentType"]);
+    if (attachmentType === "unknown") {
+        throw new Error("'unknown' attachmentType not supported");
+    }
+    return Object.assign(Object.assign({}, rest), { attachmentType: attachmentType });
+};
+/**
+ * @internal
+ * Mapping send message request and options to send chat message request REST model
+ */
+const mapToSendChatMessageRequestRestModel = (sendMessageRequest, sendMessageOptions) => {
+    const { attachments } = sendMessageOptions, restOptions = tslib.__rest(sendMessageOptions, ["attachments"]);
+    let request = Object.assign(Object.assign({}, sendMessageRequest), restOptions);
+    if (attachments) {
+        request = Object.assign(Object.assign({}, request), { attachments: attachments === null || attachments === void 0 ? void 0 : attachments.map((attachment) => mapToChatAttachmentRestModel(attachment)) });
+    }
+    return request;
+};
+/**
+ * @internal
+ * Mapping update message options to update chat message request REST model
+ */
+const mapToUpdateChatMessageRequestRestModel = (updateMessageOptions) => {
+    const { attachments } = updateMessageOptions, restOptions = tslib.__rest(updateMessageOptions, ["attachments"]);
+    let request = Object.assign({}, restOptions);
+    if (attachments) {
+        request = Object.assign(Object.assign({}, request), { attachments: attachments === null || attachments === void 0 ? void 0 : attachments.map((attachment) => mapToChatAttachmentRestModel(attachment)) });
+    }
+    return request;
+};
 /**
  * @internal
  * Mapping chat participant REST model to chat participant SDK model
@@ -63,11 +99,19 @@ const mapToChatParticipantSdkModel = (chatParticipant) => {
     const { communicationIdentifier } = chatParticipant, rest = tslib.__rest(chatParticipant, ["communicationIdentifier"]);
     return Object.assign(Object.assign({}, rest), { id: communicationCommon.deserializeCommunicationIdentifier(communicationIdentifier) });
 };
+/**
+ * @internal
+ * Mapping chat attachment REST model to chat attachment SDK model
+ */
+const mapToChatAttachmentSdkModel = (chatAttachment) => {
+    const { attachmentType } = chatAttachment, rest = tslib.__rest(chatAttachment, ["attachmentType"]);
+    return Object.assign(Object.assign({}, rest), { attachmentType: attachmentType });
+};
 /**
  * @internal
  */
 const mapToChatContentSdkModel = (content) => {
-    const { participants, initiatorCommunicationIdentifier } = content, otherChatContents = tslib.__rest(content, ["participants", "initiatorCommunicationIdentifier"]);
+    const { participants, attachments, initiatorCommunicationIdentifier } = content, otherChatContents = tslib.__rest(content, ["participants", "attachments", "initiatorCommunicationIdentifier"]);
     let result = Object.assign({}, otherChatContents);
     if (initiatorCommunicationIdentifier) {
         const initiator = communicationCommon.deserializeCommunicationIdentifier(initiatorCommunicationIdentifier);
@@ -76,6 +120,9 @@ const mapToChatContentSdkModel = (content) => {
     if (participants) {
         result = Object.assign(Object.assign({}, result), { participants: participants === null || participants === void 0 ? void 0 : participants.map((participant) => mapToChatParticipantSdkModel(participant)) });
     }
+    if (attachments) {
+        result = Object.assign(Object.assign({}, result), { attachments: attachments === null || attachments === void 0 ? void 0 : attachments.map((attachment) => mapToChatAttachmentSdkModel(attachment)) });
+    }
     return result;
 };
 /**
@@ -94,18 +141,35 @@ const mapToChatMessageSdkModel = (chatMessage) => {
     }
     return result;
 };
+/**
+ * @internal
+ * Mapping chat retention policy REST model to chat retention policy SDK model
+ */
+const mapToRetentionPolicySdkModel = (retentionPolicy) => {
+    if (retentionPolicy.kind === "threadCreationDate") {
+        return retentionPolicy;
+    }
+    if (retentionPolicy.kind === "none") {
+        return retentionPolicy;
+    }
+    else {
+        throw new Error(`Retention Policy ${retentionPolicy.kind} is not supported`);
+    }
+};
 /**
  * @internal
  * Mapping chat thread REST model to chat thread SDK model
  */
 const mapToChatThreadPropertiesSdkModel = (chatThread) => {
-    const { createdByCommunicationIdentifier } = chatThread, rest = tslib.__rest(chatThread, ["createdByCommunicationIdentifier"]);
+    const { createdByCommunicationIdentifier, retentionPolicy } = chatThread, rest = tslib.__rest(chatThread, ["createdByCommunicationIdentifier", "retentionPolicy"]);
+    let result = Object.assign({}, rest);
     if (createdByCommunicationIdentifier) {
-        return Object.assign(Object.assign({}, rest), { createdBy: communicationCommon.deserializeCommunicationIdentifier(createdByCommunicationIdentifier) });
+        result = Object.assign(Object.assign({}, result), { createdBy: communicationCommon.deserializeCommunicationIdentifier(createdByCommunicationIdentifier) });
     }
-    else {
-        return Object.assign({}, rest);
+    if (retentionPolicy) {
+        result = Object.assign(Object.assign({}, result), { retentionPolicy: mapToRetentionPolicySdkModel(retentionPolicy) });
     }
+    return result;
 };
 /**
  * @internal
@@ -139,7 +203,7 @@ const mapToReadReceiptSdkModel = (readReceipt) => {
 const tracingClient = coreTracing.createTracingClient({
     namespace: "Azure.Communication",
     packageName: "@azure/communication-chat",
-    packageVersion: "1.5.0-beta.2",
+    packageVersion: "1.6.0-beta.1",
 });
 
 /*
@@ -244,6 +308,13 @@ const CommunicationIdentifierModel = {
                     className: "MicrosoftTeamsUserIdentifierModel",
                 },
             },
+            microsoftTeamsApp: {
+                serializedName: "microsoftTeamsApp",
+                type: {
+                    name: "Composite",
+                    className: "MicrosoftTeamsAppIdentifierModel",
+                },
+            },
         },
     },
 };
@@ -304,6 +375,27 @@ const MicrosoftTeamsUserIdentifierModel = {
         },
     },
 };
+const MicrosoftTeamsAppIdentifierModel = {
+    type: {
+        name: "Composite",
+        className: "MicrosoftTeamsAppIdentifierModel",
+        modelProperties: {
+            appId: {
+                serializedName: "appId",
+                required: true,
+                type: {
+                    name: "String",
+                },
+            },
+            cloud: {
+                serializedName: "cloud",
+                type: {
+                    name: "String",
+                },
+            },
+        },
+    },
+};
 const CommunicationErrorResponse = {
     type: {
         name: "Composite",
@@ -421,6 +513,59 @@ const SendChatMessageRequest = {
                     value: { type: { name: "String" } },
                 },
             },
+            attachments: {
+                serializedName: "attachments",
+                type: {
+                    name: "Sequence",
+                    element: {
+                        type: {
+                            name: "Composite",
+                            className: "ChatAttachment",
+                        },
+                    },
+                },
+            },
+        },
+    },
+};
+const ChatAttachment = {
+    type: {
+        name: "Composite",
+        className: "ChatAttachment",
+        modelProperties: {
+            id: {
+                serializedName: "id",
+                required: true,
+                type: {
+                    name: "String",
+                },
+            },
+            attachmentType: {
+                serializedName: "attachmentType",
+                required: true,
+                type: {
+                    name: "Enum",
+                    allowedValues: ["image", "file"],
+                },
+            },
+            name: {
+                serializedName: "name",
+                type: {
+                    name: "String",
+                },
+            },
+            url: {
+                serializedName: "url",
+                type: {
+                    name: "String",
+                },
+            },
+            previewUrl: {
+                serializedName: "previewUrl",
+                type: {
+                    name: "String",
+                },
+            },
         },
     },
 };
@@ -641,47 +786,6 @@ const ChatParticipant = {
         },
     },
 };
-const ChatAttachment = {
-    type: {
-        name: "Composite",
-        className: "ChatAttachment",
-        modelProperties: {
-            id: {
-                serializedName: "id",
-                required: true,
-                type: {
-                    name: "String",
-                },
-            },
-            attachmentType: {
-                serializedName: "attachmentType",
-                required: true,
-                type: {
-                    name: "Enum",
-                    allowedValues: ["image", "file"],
-                },
-            },
-            name: {
-                serializedName: "name",
-                type: {
-                    name: "String",
-                },
-            },
-            url: {
-                serializedName: "url",
-                type: {
-                    name: "String",
-                },
-            },
-            previewUrl: {
-                serializedName: "previewUrl",
-                type: {
-                    name: "String",
-                },
-            },
-        },
-    },
-};
 const UpdateChatMessageRequest = {
     type: {
         name: "Composite",
@@ -700,6 +804,18 @@ const UpdateChatMessageRequest = {
                     value: { type: { name: "String" } },
                 },
             },
+            attachments: {
+                serializedName: "attachments",
+                type: {
+                    name: "Sequence",
+                    element: {
+                        type: {
+                            name: "Composite",
+                            className: "ChatAttachment",
+                        },
+                    },
+                },
+            },
         },
     },
 };
@@ -804,6 +920,34 @@ const CreateChatThreadRequest = {
                     value: { type: { name: "String" } },
                 },
             },
+            retentionPolicy: {
+                serializedName: "retentionPolicy",
+                type: {
+                    name: "Composite",
+                    className: "ChatRetentionPolicy",
+                },
+            },
+        },
+    },
+};
+const ChatRetentionPolicy = {
+    type: {
+        name: "Composite",
+        className: "ChatRetentionPolicy",
+        uberParent: "ChatRetentionPolicy",
+        polymorphicDiscriminator: {
+            serializedName: "kind",
+            clientName: "kind",
+        },
+        modelProperties: {
+            kind: {
+                serializedName: "kind",
+                required: true,
+                type: {
+                    name: "Enum",
+                    allowedValues: ["threadCreationDate", "none"],
+                },
+            },
         },
     },
 };
@@ -881,6 +1025,13 @@ const ChatThreadProperties = {
                     value: { type: { name: "String" } },
                 },
             },
+            retentionPolicy: {
+                serializedName: "retentionPolicy",
+                type: {
+                    name: "Composite",
+                    className: "ChatRetentionPolicy",
+                },
+            },
         },
     },
 };
@@ -965,6 +1116,13 @@ const UpdateChatThreadRequest = {
                     value: { type: { name: "String" } },
                 },
             },
+            retentionPolicy: {
+                serializedName: "retentionPolicy",
+                type: {
+                    name: "Composite",
+                    className: "ChatRetentionPolicy",
+                },
+            },
         },
     },
 };
@@ -982,6 +1140,136 @@ const SendTypingNotificationRequest = {
         },
     },
 };
+const UploadChatImageResult = {
+    type: {
+        name: "Composite",
+        className: "UploadChatImageResult",
+        modelProperties: {
+            id: {
+                serializedName: "id",
+                required: true,
+                type: {
+                    name: "String",
+                },
+            },
+            attachmentType: {
+                serializedName: "attachmentType",
+                type: {
+                    name: "Enum",
+                    allowedValues: ["image", "file"],
+                },
+            },
+            name: {
+                serializedName: "name",
+                type: {
+                    name: "String",
+                },
+            },
+        },
+    },
+};
+const ErrorResponse = {
+    type: {
+        name: "Composite",
+        className: "ErrorResponse",
+        modelProperties: {
+            error: {
+                serializedName: "error",
+                type: {
+                    name: "Composite",
+                    className: "ErrorModel",
+                },
+            },
+        },
+    },
+};
+const ErrorModel = {
+    type: {
+        name: "Composite",
+        className: "ErrorModel",
+        modelProperties: {
+            code: {
+                serializedName: "code",
+                required: true,
+                type: {
+                    name: "String",
+                },
+            },
+            message: {
+                serializedName: "message",
+                required: true,
+                type: {
+                    name: "String",
+                },
+            },
+            details: {
+                serializedName: "details",
+                type: {
+                    name: "Sequence",
+                    element: {
+                        type: {
+                            name: "Composite",
+                            className: "ErrorDetail",
+                        },
+                    },
+                },
+            },
+        },
+    },
+};
+const ErrorDetail = {
+    type: {
+        name: "Composite",
+        className: "ErrorDetail",
+        modelProperties: {
+            code: {
+                serializedName: "code",
+                required: true,
+                type: {
+                    name: "String",
+                },
+            },
+            message: {
+                serializedName: "message",
+                required: true,
+                type: {
+                    name: "String",
+                },
+            },
+        },
+    },
+};
+const ThreadCreationDateRetentionPolicy = {
+    serializedName: "threadCreationDate",
+    type: {
+        name: "Composite",
+        className: "ThreadCreationDateRetentionPolicy",
+        uberParent: "ChatRetentionPolicy",
+        polymorphicDiscriminator: ChatRetentionPolicy.type.polymorphicDiscriminator,
+        modelProperties: Object.assign(Object.assign({}, ChatRetentionPolicy.type.modelProperties), { deleteThreadAfterDays: {
+                serializedName: "deleteThreadAfterDays",
+                required: true,
+                type: {
+                    name: "Number",
+                },
+            } }),
+    },
+};
+const NoneRetentionPolicy = {
+    serializedName: "none",
+    type: {
+        name: "Composite",
+        className: "NoneRetentionPolicy",
+        uberParent: "ChatRetentionPolicy",
+        polymorphicDiscriminator: ChatRetentionPolicy.type.polymorphicDiscriminator,
+        modelProperties: Object.assign({}, ChatRetentionPolicy.type.modelProperties),
+    },
+};
+let discriminators = {
+    ChatRetentionPolicy: ChatRetentionPolicy,
+    "ChatRetentionPolicy.threadCreationDate": ThreadCreationDateRetentionPolicy,
+    "ChatRetentionPolicy.none": NoneRetentionPolicy,
+};
 
 var Mappers = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -996,6 +1284,7 @@ var Mappers = /*#__PURE__*/Object.freeze({
     ChatMessagesCollection: ChatMessagesCollection,
     ChatParticipant: ChatParticipant,
     ChatParticipantsCollection: ChatParticipantsCollection,
+    ChatRetentionPolicy: ChatRetentionPolicy,
     ChatThreadItem: ChatThreadItem,
     ChatThreadProperties: ChatThreadProperties,
     ChatThreadsItemCollection: ChatThreadsItemCollection,
@@ -1004,14 +1293,22 @@ var Mappers = /*#__PURE__*/Object.freeze({
     CommunicationUserIdentifierModel: CommunicationUserIdentifierModel,
     CreateChatThreadRequest: CreateChatThreadRequest,
     CreateChatThreadResult: CreateChatThreadResult,
+    ErrorDetail: ErrorDetail,
+    ErrorModel: ErrorModel,
+    ErrorResponse: ErrorResponse,
+    MicrosoftTeamsAppIdentifierModel: MicrosoftTeamsAppIdentifierModel,
     MicrosoftTeamsUserIdentifierModel: MicrosoftTeamsUserIdentifierModel,
+    NoneRetentionPolicy: NoneRetentionPolicy,
     PhoneNumberIdentifierModel: PhoneNumberIdentifierModel,
     SendChatMessageRequest: SendChatMessageRequest,
     SendChatMessageResult: SendChatMessageResult,
     SendReadReceiptRequest: SendReadReceiptRequest,
     SendTypingNotificationRequest: SendTypingNotificationRequest,
+    ThreadCreationDateRetentionPolicy: ThreadCreationDateRetentionPolicy,
     UpdateChatMessageRequest: UpdateChatMessageRequest,
-    UpdateChatThreadRequest: UpdateChatThreadRequest
+    UpdateChatThreadRequest: UpdateChatThreadRequest,
+    UploadChatImageResult: UploadChatImageResult,
+    discriminators: discriminators
 });
 
 /*
@@ -1074,7 +1371,7 @@ const skip = {
 const apiVersion = {
     parameterPath: "apiVersion",
     mapper: {
-        defaultValue: "2024-03-01-preview",
+        defaultValue: "2024-03-15-preview",
         isConstant: true,
         serializedName: "api-version",
         type: {
@@ -1151,6 +1448,78 @@ const sendTypingNotificationRequest = {
     parameterPath: ["options", "sendTypingNotificationRequest"],
     mapper: SendTypingNotificationRequest,
 };
+const contentType2 = {
+    parameterPath: ["options", "contentType"],
+    mapper: {
+        defaultValue: "application/octet-stream",
+        isConstant: true,
+        serializedName: "Content-Type",
+        type: {
+            name: "String",
+        },
+    },
+};
+const chatImageFile = {
+    parameterPath: "chatImageFile",
+    mapper: {
+        serializedName: "chatImageFile",
+        required: true,
+        type: {
+            name: "Stream",
+        },
+    },
+};
+const accept1 = {
+    parameterPath: "accept",
+    mapper: {
+        defaultValue: "application/json",
+        isConstant: true,
+        serializedName: "Accept",
+        type: {
+            name: "String",
+        },
+    },
+};
+const imageFilename = {
+    parameterPath: ["options", "imageFilename"],
+    mapper: {
+        serializedName: "image-filename",
+        type: {
+            name: "String",
+        },
+    },
+};
+const accept2 = {
+    parameterPath: "accept",
+    mapper: {
+        defaultValue: "application/json, image/gif, image/jpeg, image/png, image/bmp, image/tiff",
+        isConstant: true,
+        serializedName: "Accept",
+        type: {
+            name: "String",
+        },
+    },
+};
+const imageId = {
+    parameterPath: "imageId",
+    mapper: {
+        serializedName: "imageId",
+        required: true,
+        type: {
+            name: "String",
+        },
+    },
+};
+const imageViewType = {
+    parameterPath: "imageViewType",
+    mapper: {
+        serializedName: "imageViewType",
+        required: true,
+        type: {
+            name: "String",
+        },
+    },
+};
 const nextLink = {
     parameterPath: "nextLink",
     mapper: {
@@ -1331,6 +1700,40 @@ class ChatThreadImpl {
             return this.client.sendOperationRequest({ chatThreadId, options }, sendTypingNotificationOperationSpec);
         });
     }
+    /**
+     * Upload an image in a thread, on behalf of a user.
+     * @param chatThreadId Thread id where the uploaded image belongs to. (Teams meeting only)
+     * @param chatImageFile Image binary data, allowed image formats: jpeg, png, gif, heic, webp
+     * @param options The options parameters.
+     */
+    async uploadChatImage(chatThreadId, chatImageFile, options) {
+        return tracingClient.withSpan("ChatApiClient.uploadChatImage", options !== null && options !== void 0 ? options : {}, async (options) => {
+            return this.client.sendOperationRequest({ chatThreadId, chatImageFile, options }, uploadChatImageOperationSpec);
+        });
+    }
+    /**
+     * Get an image by view type.
+     * @param chatThreadId The thread id to which the message was sent.
+     * @param imageId The image id.
+     * @param imageViewType The view type of image.
+     * @param options The options parameters.
+     */
+    async getChatImage(chatThreadId, imageId, imageViewType, options) {
+        return tracingClient.withSpan("ChatApiClient.getChatImage", options !== null && options !== void 0 ? options : {}, async (options) => {
+            return this.client.sendOperationRequest({ chatThreadId, imageId, imageViewType, options }, getChatImageOperationSpec);
+        });
+    }
+    /**
+     * Deletes a image.
+     * @param chatThreadId The thread id to which the message was sent.
+     * @param imageId The image id.
+     * @param options The options parameters.
+     */
+    async deleteChatImage(chatThreadId, imageId, options) {
+        return tracingClient.withSpan("ChatApiClient.deleteChatImage", options !== null && options !== void 0 ? options : {}, async (options) => {
+            return this.client.sendOperationRequest({ chatThreadId, imageId, options }, deleteChatImageOperationSpec);
+        });
+    }
     /**
      * ListChatReadReceiptsNext
      * @param chatThreadId Thread id to get the chat message read receipts for.
@@ -1770,6 +2173,70 @@ const sendTypingNotificationOperationSpec = {
     mediaType: "json",
     serializer: serializer$1,
 };
+const uploadChatImageOperationSpec = {
+    path: "/chat/threads/{chatThreadId}/images",
+    httpMethod: "POST",
+    responses: {
+        201: {
+            bodyMapper: UploadChatImageResult,
+        },
+        default: {
+            bodyMapper: ErrorResponse,
+        },
+    },
+    requestBody: chatImageFile,
+    queryParameters: [apiVersion],
+    urlParameters: [endpoint, chatThreadId],
+    headerParameters: [
+        contentType2,
+        accept1,
+        imageFilename,
+    ],
+    mediaType: "binary",
+    serializer: serializer$1,
+};
+const getChatImageOperationSpec = {
+    path: "/chat/threads/{chatThreadId}/images/{imageId}/view/{imageViewType}",
+    httpMethod: "GET",
+    responses: {
+        200: {
+            bodyMapper: {
+                type: { name: "Stream" },
+                serializedName: "parsedResponse",
+            },
+        },
+        default: {
+            bodyMapper: ErrorResponse,
+        },
+    },
+    queryParameters: [apiVersion],
+    urlParameters: [
+        endpoint,
+        chatThreadId,
+        imageId,
+        imageViewType,
+    ],
+    headerParameters: [accept2],
+    serializer: serializer$1,
+};
+const deleteChatImageOperationSpec = {
+    path: "/chat/threads/{chatThreadId}/images/{imageId}",
+    httpMethod: "DELETE",
+    responses: {
+        204: {},
+        default: {
+            bodyMapper: ErrorResponse,
+        },
+    },
+    queryParameters: [apiVersion],
+    urlParameters: [
+        endpoint,
+        chatThreadId,
+        imageId,
+    ],
+    headerParameters: [accept],
+    serializer: serializer$1,
+};
 const listChatReadReceiptsNextOperationSpec = {
     path: "{nextLink}",
     httpMethod: "GET",
@@ -2074,7 +2541,7 @@ class ChatApiClient extends coreClient__namespace.ServiceClient {
         const defaults = {
             requestContentType: "application/json; charset=utf-8",
         };
-        const packageDetails = `azsdk-js-communication-chat/1.5.0-beta.2`;
+        const packageDetails = `azsdk-js-communication-chat/1.6.0-beta.1`;
         const userAgentPrefix = options.userAgentOptions && options.userAgentOptions.userAgentPrefix
             ? `${options.userAgentOptions.userAgentPrefix} ${packageDetails}`
             : `${packageDetails}`;
@@ -2085,7 +2552,7 @@ class ChatApiClient extends coreClient__namespace.ServiceClient {
         // Parameter assignments
         this.endpoint = endpoint;
         // Assigning values to Constant parameters
-        this.apiVersion = options.apiVersion || "2024-03-01-preview";
+        this.apiVersion = options.apiVersion || "2024-03-15-preview";
         this.chatThread = new ChatThreadImpl(this);
         this.chat = new ChatImpl(this);
         this.addCustomApiVersionPolicy(options.apiVersion);
@@ -2121,6 +2588,190 @@ class ChatApiClient extends coreClient__namespace.ServiceClient {
 // Licensed under the MIT license.
 const logger = logger$1.createClientLogger("communication-chat");
 
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+// Temporary workaround with local copy of XhrHttpClient
+function isNodeReadableStream(body) {
+    return body && typeof body.pipe === "function";
+}
+/**
+ * Checks if the body is a Blob or Blob-like
+ * @internal
+ */
+function isBlob(body) {
+    // File objects count as a type of Blob, so we want to use instanceof explicitly
+    return (typeof Blob === "function" || typeof Blob === "object") && body instanceof Blob;
+}
+/**
+ * Checks if the body is a ReadableStream supported by browsers
+ * @internal
+ */
+function isReadableStream(body) {
+    return Boolean(body &&
+        typeof body.getReader === "function" &&
+        typeof body.tee === "function");
+}
+/**
+ * A HttpClient implementation that uses XMLHttpRequest to send HTTP requests.
+ * @internal
+ */
+class XhrHttpClient {
+    /**
+     * Makes a request over an underlying transport layer and returns the response.
+     * @param request - The request to be made.
+     */
+    async sendRequest(request) {
+        var _a;
+        const url = new URL(request.url);
+        const isInsecure = url.protocol !== "https:";
+        if (isInsecure && !request.allowInsecureConnection) {
+            throw new Error(`Cannot connect to ${request.url} while allowInsecureConnection is false.`);
+        }
+        const xhr = new XMLHttpRequest();
+        if (request.proxySettings) {
+            throw new Error("HTTP proxy is not supported in browser environment");
+        }
+        const abortSignal = request.abortSignal;
+        if (abortSignal) {
+            if (abortSignal.aborted) {
+                throw new abortController.AbortError("The operation was aborted.");
+            }
+            const listener = () => {
+                xhr.abort();
+            };
+            abortSignal.addEventListener("abort", listener);
+            xhr.addEventListener("readystatechange", () => {
+                if (xhr.readyState === XMLHttpRequest.DONE) {
+                    abortSignal.removeEventListener("abort", listener);
+                }
+            });
+        }
+        addProgressListener(xhr.upload, request.onUploadProgress);
+        addProgressListener(xhr, request.onDownloadProgress);
+        xhr.open(request.method, request.url);
+        xhr.timeout = request.timeout;
+        xhr.withCredentials = request.withCredentials;
+        for (const [name, value] of request.headers) {
+            xhr.setRequestHeader(name, value);
+        }
+        xhr.responseType = ((_a = request.streamResponseStatusCodes) === null || _a === void 0 ? void 0 : _a.size) ? "blob" : "text";
+        const body = typeof request.body === "function" ? request.body() : request.body;
+        if (isNodeReadableStream(body) || isReadableStream(body)) {
+            throw new Error("Streams are not supported by xhrHttpClient.");
+        }
+        xhr.send(body === undefined ? null : body);
+        if (xhr.responseType === "blob") {
+            return new Promise((resolve, reject) => {
+                handleBlobResponse(xhr, request, resolve, reject);
+                rejectOnTerminalEvent(request, xhr, reject);
+            });
+        }
+        else {
+            return new Promise(function (resolve, reject) {
+                xhr.addEventListener("load", () => resolve({
+                    request,
+                    status: xhr.status,
+                    headers: parseHeaders(xhr),
+                    bodyAsText: xhr.responseText,
+                }));
+                rejectOnTerminalEvent(request, xhr, reject);
+            });
+        }
+    }
+}
+function handleBlobResponse(xhr, request, res, rej) {
+    xhr.addEventListener("readystatechange", () => {
+        var _a, _b;
+        // Resolve as soon as headers are loaded
+        if (xhr.readyState === XMLHttpRequest.HEADERS_RECEIVED) {
+            if (
+            // Value of POSITIVE_INFINITY in streamResponseStatusCodes is considered as any status code
+            ((_a = request.streamResponseStatusCodes) === null || _a === void 0 ? void 0 : _a.has(Number.POSITIVE_INFINITY)) ||
+                ((_b = request.streamResponseStatusCodes) === null || _b === void 0 ? void 0 : _b.has(xhr.status))) {
+                const blobBody = new Promise((resolve, reject) => {
+                    xhr.addEventListener("load", () => {
+                        resolve(xhr.response);
+                    });
+                    rejectOnTerminalEvent(request, xhr, reject);
+                });
+                res({
+                    request,
+                    status: xhr.status,
+                    headers: parseHeaders(xhr),
+                    blobBody,
+                });
+            }
+            else {
+                xhr.addEventListener("load", () => {
+                    // xhr.response is of Blob type if the request is sent with xhr.responseType === "blob"
+                    // but the status code is not one of the stream response status codes,
+                    // so treat it as text and convert from Blob to text
+                    if (xhr.response) {
+                        xhr.response
+                            .text()
+                            .then((text) => {
+                            res({
+                                request: request,
+                                status: xhr.status,
+                                headers: parseHeaders(xhr),
+                                bodyAsText: text,
+                            });
+                            return;
+                        })
+                            .catch((e) => {
+                            rej(e);
+                        });
+                    }
+                    else {
+                        res({
+                            request,
+                            status: xhr.status,
+                            headers: parseHeaders(xhr),
+                        });
+                    }
+                });
+            }
+        }
+    });
+}
+function addProgressListener(xhr, listener) {
+    if (listener) {
+        xhr.addEventListener("progress", (rawEvent) => listener({
+            loadedBytes: rawEvent.loaded,
+        }));
+    }
+}
+function parseHeaders(xhr) {
+    const responseHeaders = coreRestPipeline.createHttpHeaders();
+    const headerLines = xhr
+        .getAllResponseHeaders()
+        .trim()
+        .split(/[\r\n]+/);
+    for (const line of headerLines) {
+        const index = line.indexOf(":");
+        const headerName = line.slice(0, index);
+        const headerValue = line.slice(index + 2);
+        responseHeaders.set(headerName, headerValue);
+    }
+    return responseHeaders;
+}
+function rejectOnTerminalEvent(request, xhr, reject) {
+    xhr.addEventListener("error", () => reject(new coreRestPipeline.RestError(`Failed to send request to ${request.url}`, {
+        code: coreRestPipeline.RestError.REQUEST_SEND_ERROR,
+        request,
+    })));
+    const abortError = new abortController.AbortError("The operation was aborted.");
+    xhr.addEventListener("abort", () => reject(abortError));
+    xhr.addEventListener("timeout", () => reject(abortError));
+}
+/**
+ * Create a new HttpClient instance for the browser environment.
+ * @internal
+ */
+function createXhrHttpClient() {
+    return new XhrHttpClient();
+}
+
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
 /**
@@ -2158,6 +2809,10 @@ class ChatThreadClient {
         this.client = new ChatApiClient(this.endpoint, Object.assign({ endpoint: this.endpoint }, internalPipelineOptions));
         const authPolicy = createCommunicationTokenCredentialPolicy(this.tokenCredential);
         this.client.pipeline.addPolicy(authPolicy);
+        if (typeof XMLHttpRequest !== "undefined") {
+            this.xhrClient = new ChatApiClient(this.endpoint, Object.assign(Object.assign({ endpoint: this.endpoint }, internalPipelineOptions), { httpClient: createXhrHttpClient() }));
+            this.xhrClient.pipeline.addPolicy(authPolicy);
+        }
     }
     /**
      * Gets a chat thread.
@@ -2199,7 +2854,7 @@ class ChatThreadClient {
         return tracingClient.withSpan("ChatThreadClient-SendMessage", options, async (updatedOptions) => {
             // reset typing notification clock
             this.timeOfLastTypingRequest = undefined;
-            const result = await this.client.chatThread.sendChatMessage(this.threadId, Object.assign(Object.assign({}, request), options), updatedOptions);
+            const result = await this.client.chatThread.sendChatMessage(this.threadId, mapToSendChatMessageRequestRestModel(request, options), updatedOptions);
             return result;
         });
     }
@@ -2215,8 +2870,8 @@ class ChatThreadClient {
             return mapToChatMessageSdkModel(result);
         });
     }
-    listMessagesPage(pageSettings, options = {}) {
-        return tslib.__asyncGenerator(this, arguments, function* listMessagesPage_1() {
+    listMessagesPage(pageSettings_1) {
+        return tslib.__asyncGenerator(this, arguments, function* listMessagesPage_1(pageSettings, options = {}) {
             if (!pageSettings.continuationToken) {
                 const currentSetResponse = yield tslib.__await(this.client.chatThread.listChatMessages(this.threadId, options));
                 pageSettings.continuationToken = currentSetResponse.nextLink;
@@ -2305,7 +2960,7 @@ class ChatThreadClient {
      */
     async updateMessage(messageId, options = {}) {
         return tracingClient.withSpan("ChatThreadClient-UpdateMessage", options, async (updatedOptions) => {
-            await this.client.chatThread.updateChatMessage(this.threadId, messageId, options, updatedOptions);
+            await this.client.chatThread.updateChatMessage(this.threadId, messageId, mapToUpdateChatMessageRequestRestModel(options), updatedOptions);
         });
     }
     /**
@@ -2319,8 +2974,8 @@ class ChatThreadClient {
             return result;
         });
     }
-    listParticipantsPage(continuationState, options = {}) {
-        return tslib.__asyncGenerator(this, arguments, function* listParticipantsPage_1() {
+    listParticipantsPage(continuationState_1) {
+        return tslib.__asyncGenerator(this, arguments, function* listParticipantsPage_1(continuationState, options = {}) {
             if (!continuationState.continuationToken) {
                 const currentSetResponse = yield tslib.__await(this.client.chatThread.listChatParticipants(this.threadId, options));
                 continuationState.continuationToken = currentSetResponse.nextLink;
@@ -2431,8 +3086,8 @@ class ChatThreadClient {
             await this.client.chatThread.sendChatReadReceipt(this.threadId, request, updatedOptions);
         });
     }
-    listReadReceiptsPage(continuationState, options = {}) {
-        return tslib.__asyncGenerator(this, arguments, function* listReadReceiptsPage_1() {
+    listReadReceiptsPage(continuationState_1) {
+        return tslib.__asyncGenerator(this, arguments, function* listReadReceiptsPage_1(continuationState, options = {}) {
             if (!continuationState.continuationToken) {
                 const currentSetResponse = yield tslib.__await(this.client.chatThread.listChatReadReceipts(this.threadId, options));
                 continuationState.continuationToken = currentSetResponse.nextLink;
@@ -2514,6 +3169,72 @@ class ChatThreadClient {
         }
         return true;
     }
+    async uploadImage(image, imageFilename, imageBytesLengthOrOptions, options = {}) {
+        let uploadImageOptions = {};
+        if (imageBytesLengthOrOptions !== undefined) {
+            if (typeof imageBytesLengthOrOptions === "number") {
+                uploadImageOptions = Object.assign(Object.assign({}, options), { imageBytesLength: imageBytesLengthOrOptions });
+            }
+            else {
+                uploadImageOptions = Object.assign(Object.assign({}, options), imageBytesLengthOrOptions);
+            }
+        }
+        return tracingClient.withSpan("ChatThreadClient-UploadImage", uploadImageOptions, async (updatedOptions) => {
+            let result;
+            if (this.xhrClient && // is browser
+                ((!this.supportsReadableStream() && isReadableStream(image)) || // is readable stream but no support, need to convert
+                    !isReadableStream(image))) {
+                // use xhrClient if (to support onUploadProgress)
+                // - is readable stream but no support => convert to ArrayBuffer (so will have content-length)
+                // - is not readable stream
+                result = await this.xhrClient.chatThread.uploadChatImage(this.threadId, isReadableStream(image) ? await this.getArrayBufferFromReadableStream(image) : image, Object.assign({ imageFilename }, updatedOptions));
+            }
+            else {
+                // backend (node fetch client) or readable readable stream
+                // Backend (no browser) need to convert Blob/ReadableStream to ArrayBuffer
+                let chatImageFile = image;
+                if (isBlob(image)) {
+                    chatImageFile = await this.getArrayBufferFromBlob(image);
+                }
+                else if (isReadableStream(image)) {
+                    chatImageFile = await this.getArrayBufferFromReadableStream(image);
+                }
+                result = await this.client.chatThread.uploadChatImage(this.threadId, chatImageFile, Object.assign({ imageFilename }, updatedOptions));
+            }
+            return result;
+        });
+    }
+    /**
+     * Deletes an image identified by threadId and imageId
+     * @param imageId - The image id of the image.
+     * @param options - Operation options.
+     */
+    deleteImage(imageId, options = {}) {
+        return tracingClient.withSpan("ChatThreadClient-DeleteImage", options, async (updatedOptions) => {
+            await this.client.chatThread.deleteChatImage(this.threadId, imageId, updatedOptions);
+        });
+    }
+    supportsReadableStream() {
+        let duplexAccessed = false;
+        const hasContentType = new Request("", {
+            body: new ReadableStream(),
+            method: "POST",
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            get duplex() {
+                duplexAccessed = true;
+                return "half";
+            },
+        }).headers.has("Content-Type");
+        return duplexAccessed && !hasContentType;
+    }
+    async getArrayBufferFromReadableStream(body) {
+        const arrayBuffer = await new Response(body).arrayBuffer();
+        return new Uint8Array(arrayBuffer);
+    }
+    async getArrayBufferFromBlob(body) {
+        return new Uint8Array(await body.arrayBuffer());
+    }
 }
 
 // Copyright (c) Microsoft Corporation.
@@ -2564,16 +3285,16 @@ class ChatClient {
         this.emitter = new events.EventEmitter();
         this.isRealtimeNotificationsStarted = false;
         this.tokenCredential = credential;
-        this.clientOptions = Object.assign({}, options);
         const internalPipelineOptions = Object.assign(Object.assign({}, options), {
             loggingOptions: {
                 logger: logger.info,
             },
         });
         this.client = new ChatApiClient(this.endpoint, Object.assign({ endpoint: this.endpoint }, internalPipelineOptions));
-        this.clientOptions.signalingClientOptions = Object.assign(Object.assign({}, this.clientOptions.signalingClientOptions), { resourceEndpoint: this.endpoint, gatewayApiVersion: this.client.apiVersion });
         const authPolicy = createCommunicationTokenCredentialPolicy(this.tokenCredential);
         this.client.pipeline.addPolicy(authPolicy);
+        this.clientOptions = Object.assign({}, options);
+        this.clientOptions.signalingClientOptions = Object.assign(Object.assign({}, this.clientOptions.signalingClientOptions), { resourceEndpoint: this.endpoint, gatewayApiVersion: this.client.apiVersion });
         this.signalingClient = getSignalingClient(credential, logger, this.clientOptions.signalingClientOptions);
     }
     /**
@@ -2599,12 +3320,13 @@ class ChatClient {
                 topic: request.topic,
                 participants: (_b = options.participants) === null || _b === void 0 ? void 0 : _b.map((participant) => mapToChatParticipantRestModel(participant)),
                 metadata: options.metadata,
+                retentionPolicy: options.retentionPolicy,
             }, updatedRestModelOptions);
             return mapToCreateChatThreadResultSdkModel(result);
         });
     }
-    listChatThreadsPage(continuationState, options = {}) {
-        return tslib.__asyncGenerator(this, arguments, function* listChatThreadsPage_1() {
+    listChatThreadsPage(continuationState_1) {
+        return tslib.__asyncGenerator(this, arguments, function* listChatThreadsPage_1(continuationState, options = {}) {
             if (!continuationState.continuationToken) {
                 const currentSetResponse = yield tslib.__await(this.client.chat.listChatThreads(options));
                 continuationState.continuationToken = currentSetResponse.nextLink;