@azure/web-pubsub 1.0.0-beta.2 → 1.0.1-alpha.20211215.2

package/dist/index.js

@@ -5,17 +5,419 @@ Object.defineProperty(exports, '__esModule', { value: true });
 function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
 
 var coreAuth = require('@azure/core-auth');
-var tslib = require('tslib');
-var coreHttp = require('@azure/core-http');
+var coreRestPipeline = require('@azure/core-rest-pipeline');
+var coreClient = require('@azure/core-client');
 var coreTracing = require('@azure/core-tracing');
 var jwt = _interopDefault(require('jsonwebtoken'));
 var logger$1 = require('@azure/logger');
 var url = require('url');
 
-const $host = {
-    parameterPath: "$host",
+/*
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ *
+ * Code generated by Microsoft (R) AutoRest Code Generator.
+ * Changes may cause incorrect behavior and will be lost if the code is regenerated.
+ */
+const ClientTokenResponse = {
+    type: {
+        name: "Composite",
+        className: "ClientTokenResponse",
+        modelProperties: {
+            token: {
+                serializedName: "token",
+                type: {
+                    name: "String"
+                }
+            }
+        }
+    }
+};
+const ErrorDetail = {
+    type: {
+        name: "Composite",
+        className: "ErrorDetail",
+        modelProperties: {
+            code: {
+                serializedName: "code",
+                type: {
+                    name: "String"
+                }
+            },
+            message: {
+                serializedName: "message",
+                type: {
+                    name: "String"
+                }
+            },
+            target: {
+                serializedName: "target",
+                type: {
+                    name: "String"
+                }
+            },
+            details: {
+                serializedName: "details",
+                type: {
+                    name: "Sequence",
+                    element: {
+                        type: {
+                            name: "Composite",
+                            className: "ErrorDetail"
+                        }
+                    }
+                }
+            },
+            inner: {
+                serializedName: "inner",
+                type: {
+                    name: "Composite",
+                    className: "InnerError"
+                }
+            }
+        }
+    }
+};
+const InnerError = {
+    type: {
+        name: "Composite",
+        className: "InnerError",
+        modelProperties: {
+            code: {
+                serializedName: "code",
+                type: {
+                    name: "String"
+                }
+            },
+            inner: {
+                serializedName: "inner",
+                type: {
+                    name: "Composite",
+                    className: "InnerError"
+                }
+            }
+        }
+    }
+};
+const WebPubSubGenerateClientTokenExceptionHeaders = {
+    type: {
+        name: "Composite",
+        className: "WebPubSubGenerateClientTokenExceptionHeaders",
+        modelProperties: {
+            errorCode: {
+                serializedName: "x-ms-error-code",
+                type: {
+                    name: "String"
+                }
+            }
+        }
+    }
+};
+const WebPubSubCloseAllConnectionsExceptionHeaders = {
+    type: {
+        name: "Composite",
+        className: "WebPubSubCloseAllConnectionsExceptionHeaders",
+        modelProperties: {
+            errorCode: {
+                serializedName: "x-ms-error-code",
+                type: {
+                    name: "String"
+                }
+            }
+        }
+    }
+};
+const WebPubSubSendToAllExceptionHeaders = {
+    type: {
+        name: "Composite",
+        className: "WebPubSubSendToAllExceptionHeaders",
+        modelProperties: {
+            errorCode: {
+                serializedName: "x-ms-error-code",
+                type: {
+                    name: "String"
+                }
+            }
+        }
+    }
+};
+const WebPubSubConnectionExistsExceptionHeaders = {
+    type: {
+        name: "Composite",
+        className: "WebPubSubConnectionExistsExceptionHeaders",
+        modelProperties: {
+            errorCode: {
+                serializedName: "x-ms-error-code",
+                type: {
+                    name: "String"
+                }
+            }
+        }
+    }
+};
+const WebPubSubCloseConnectionExceptionHeaders = {
+    type: {
+        name: "Composite",
+        className: "WebPubSubCloseConnectionExceptionHeaders",
+        modelProperties: {
+            errorCode: {
+                serializedName: "x-ms-error-code",
+                type: {
+                    name: "String"
+                }
+            }
+        }
+    }
+};
+const WebPubSubSendToConnectionExceptionHeaders = {
+    type: {
+        name: "Composite",
+        className: "WebPubSubSendToConnectionExceptionHeaders",
+        modelProperties: {
+            errorCode: {
+                serializedName: "x-ms-error-code",
+                type: {
+                    name: "String"
+                }
+            }
+        }
+    }
+};
+const WebPubSubGroupExistsExceptionHeaders = {
+    type: {
+        name: "Composite",
+        className: "WebPubSubGroupExistsExceptionHeaders",
+        modelProperties: {
+            errorCode: {
+                serializedName: "x-ms-error-code",
+                type: {
+                    name: "String"
+                }
+            }
+        }
+    }
+};
+const WebPubSubCloseGroupConnectionsExceptionHeaders = {
+    type: {
+        name: "Composite",
+        className: "WebPubSubCloseGroupConnectionsExceptionHeaders",
+        modelProperties: {
+            errorCode: {
+                serializedName: "x-ms-error-code",
+                type: {
+                    name: "String"
+                }
+            }
+        }
+    }
+};
+const WebPubSubSendToGroupExceptionHeaders = {
+    type: {
+        name: "Composite",
+        className: "WebPubSubSendToGroupExceptionHeaders",
+        modelProperties: {
+            errorCode: {
+                serializedName: "x-ms-error-code",
+                type: {
+                    name: "String"
+                }
+            }
+        }
+    }
+};
+const WebPubSubAddConnectionToGroupExceptionHeaders = {
+    type: {
+        name: "Composite",
+        className: "WebPubSubAddConnectionToGroupExceptionHeaders",
+        modelProperties: {
+            errorCode: {
+                serializedName: "x-ms-error-code",
+                type: {
+                    name: "String"
+                }
+            }
+        }
+    }
+};
+const WebPubSubRemoveConnectionFromGroupExceptionHeaders = {
+    type: {
+        name: "Composite",
+        className: "WebPubSubRemoveConnectionFromGroupExceptionHeaders",
+        modelProperties: {
+            errorCode: {
+                serializedName: "x-ms-error-code",
+                type: {
+                    name: "String"
+                }
+            }
+        }
+    }
+};
+const WebPubSubUserExistsExceptionHeaders = {
+    type: {
+        name: "Composite",
+        className: "WebPubSubUserExistsExceptionHeaders",
+        modelProperties: {
+            errorCode: {
+                serializedName: "x-ms-error-code",
+                type: {
+                    name: "String"
+                }
+            }
+        }
+    }
+};
+const WebPubSubCloseUserConnectionsExceptionHeaders = {
+    type: {
+        name: "Composite",
+        className: "WebPubSubCloseUserConnectionsExceptionHeaders",
+        modelProperties: {
+            errorCode: {
+                serializedName: "x-ms-error-code",
+                type: {
+                    name: "String"
+                }
+            }
+        }
+    }
+};
+const WebPubSubSendToUserExceptionHeaders = {
+    type: {
+        name: "Composite",
+        className: "WebPubSubSendToUserExceptionHeaders",
+        modelProperties: {
+            errorCode: {
+                serializedName: "x-ms-error-code",
+                type: {
+                    name: "String"
+                }
+            }
+        }
+    }
+};
+const WebPubSubAddUserToGroupExceptionHeaders = {
+    type: {
+        name: "Composite",
+        className: "WebPubSubAddUserToGroupExceptionHeaders",
+        modelProperties: {
+            errorCode: {
+                serializedName: "x-ms-error-code",
+                type: {
+                    name: "String"
+                }
+            }
+        }
+    }
+};
+const WebPubSubRemoveUserFromGroupExceptionHeaders = {
+    type: {
+        name: "Composite",
+        className: "WebPubSubRemoveUserFromGroupExceptionHeaders",
+        modelProperties: {
+            errorCode: {
+                serializedName: "x-ms-error-code",
+                type: {
+                    name: "String"
+                }
+            }
+        }
+    }
+};
+const WebPubSubRemoveUserFromAllGroupsExceptionHeaders = {
+    type: {
+        name: "Composite",
+        className: "WebPubSubRemoveUserFromAllGroupsExceptionHeaders",
+        modelProperties: {
+            errorCode: {
+                serializedName: "x-ms-error-code",
+                type: {
+                    name: "String"
+                }
+            }
+        }
+    }
+};
+const WebPubSubGrantPermissionExceptionHeaders = {
+    type: {
+        name: "Composite",
+        className: "WebPubSubGrantPermissionExceptionHeaders",
+        modelProperties: {
+            errorCode: {
+                serializedName: "x-ms-error-code",
+                type: {
+                    name: "String"
+                }
+            }
+        }
+    }
+};
+const WebPubSubRevokePermissionExceptionHeaders = {
+    type: {
+        name: "Composite",
+        className: "WebPubSubRevokePermissionExceptionHeaders",
+        modelProperties: {
+            errorCode: {
+                serializedName: "x-ms-error-code",
+                type: {
+                    name: "String"
+                }
+            }
+        }
+    }
+};
+const WebPubSubCheckPermissionExceptionHeaders = {
+    type: {
+        name: "Composite",
+        className: "WebPubSubCheckPermissionExceptionHeaders",
+        modelProperties: {
+            errorCode: {
+                serializedName: "x-ms-error-code",
+                type: {
+                    name: "String"
+                }
+            }
+        }
+    }
+};
+
+var Mappers = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    ClientTokenResponse: ClientTokenResponse,
+    ErrorDetail: ErrorDetail,
+    InnerError: InnerError,
+    WebPubSubGenerateClientTokenExceptionHeaders: WebPubSubGenerateClientTokenExceptionHeaders,
+    WebPubSubCloseAllConnectionsExceptionHeaders: WebPubSubCloseAllConnectionsExceptionHeaders,
+    WebPubSubSendToAllExceptionHeaders: WebPubSubSendToAllExceptionHeaders,
+    WebPubSubConnectionExistsExceptionHeaders: WebPubSubConnectionExistsExceptionHeaders,
+    WebPubSubCloseConnectionExceptionHeaders: WebPubSubCloseConnectionExceptionHeaders,
+    WebPubSubSendToConnectionExceptionHeaders: WebPubSubSendToConnectionExceptionHeaders,
+    WebPubSubGroupExistsExceptionHeaders: WebPubSubGroupExistsExceptionHeaders,
+    WebPubSubCloseGroupConnectionsExceptionHeaders: WebPubSubCloseGroupConnectionsExceptionHeaders,
+    WebPubSubSendToGroupExceptionHeaders: WebPubSubSendToGroupExceptionHeaders,
+    WebPubSubAddConnectionToGroupExceptionHeaders: WebPubSubAddConnectionToGroupExceptionHeaders,
+    WebPubSubRemoveConnectionFromGroupExceptionHeaders: WebPubSubRemoveConnectionFromGroupExceptionHeaders,
+    WebPubSubUserExistsExceptionHeaders: WebPubSubUserExistsExceptionHeaders,
+    WebPubSubCloseUserConnectionsExceptionHeaders: WebPubSubCloseUserConnectionsExceptionHeaders,
+    WebPubSubSendToUserExceptionHeaders: WebPubSubSendToUserExceptionHeaders,
+    WebPubSubAddUserToGroupExceptionHeaders: WebPubSubAddUserToGroupExceptionHeaders,
+    WebPubSubRemoveUserFromGroupExceptionHeaders: WebPubSubRemoveUserFromGroupExceptionHeaders,
+    WebPubSubRemoveUserFromAllGroupsExceptionHeaders: WebPubSubRemoveUserFromAllGroupsExceptionHeaders,
+    WebPubSubGrantPermissionExceptionHeaders: WebPubSubGrantPermissionExceptionHeaders,
+    WebPubSubRevokePermissionExceptionHeaders: WebPubSubRevokePermissionExceptionHeaders,
+    WebPubSubCheckPermissionExceptionHeaders: WebPubSubCheckPermissionExceptionHeaders
+});
+
+/*
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ *
+ * Code generated by Microsoft (R) AutoRest Code Generator.
+ * Changes may cause incorrect behavior and will be lost if the code is regenerated.
+ */
+const endpoint = {
+    parameterPath: "endpoint",
     mapper: {
-        serializedName: "$host",
+        serializedName: "Endpoint",
         required: true,
         type: {
             name: "String"
@@ -26,7 +428,7 @@ const $host = {
 const apiVersion = {
     parameterPath: "apiVersion",
     mapper: {
-        defaultValue: "2020-10-01",
+        defaultValue: "2021-10-01",
         isConstant: true,
         serializedName: "api-version",
         type: {
@@ -34,6 +436,88 @@ const apiVersion = {
         }
     }
 };
+const accept = {
+    parameterPath: "accept",
+    mapper: {
+        defaultValue: "application/json, text/json",
+        isConstant: true,
+        serializedName: "Accept",
+        type: {
+            name: "String"
+        }
+    }
+};
+const hub = {
+    parameterPath: "hub",
+    mapper: {
+        constraints: {
+            Pattern: new RegExp("^[A-Za-z][A-Za-z0-9_`,.[\\]]{0,127}$")
+        },
+        serializedName: "hub",
+        required: true,
+        type: {
+            name: "String"
+        }
+    }
+};
+const userId = {
+    parameterPath: ["options", "userId"],
+    mapper: {
+        serializedName: "userId",
+        type: {
+            name: "String"
+        }
+    }
+};
+const roles = {
+    parameterPath: ["options", "roles"],
+    mapper: {
+        serializedName: "role",
+        type: {
+            name: "Sequence",
+            element: {
+                type: {
+                    name: "String"
+                }
+            }
+        }
+    },
+    collectionFormat: "Multi"
+};
+const expirationTimeInMinutes = {
+    parameterPath: ["options", "expirationTimeInMinutes"],
+    mapper: {
+        defaultValue: 60,
+        serializedName: "minutesToExpire",
+        type: {
+            name: "Number"
+        }
+    }
+};
+const excluded = {
+    parameterPath: ["options", "excluded"],
+    mapper: {
+        serializedName: "excluded",
+        type: {
+            name: "Sequence",
+            element: {
+                type: {
+                    name: "String"
+                }
+            }
+        }
+    },
+    collectionFormat: "Multi"
+};
+const reason = {
+    parameterPath: ["options", "reason"],
+    mapper: {
+        serializedName: "reason",
+        type: {
+            name: "String"
+        }
+    }
+};
 const contentType = {
     parameterPath: "contentType",
     mapper: {
@@ -55,6 +539,17 @@ const message = {
         }
     }
 };
+const accept1 = {
+    parameterPath: "accept",
+    mapper: {
+        defaultValue: "application/json, text/json",
+        isConstant: true,
+        serializedName: "Accept",
+        type: {
+            name: "String"
+        }
+    }
+};
 const contentType1 = {
     parameterPath: "contentType",
     mapper: {
@@ -76,18 +571,19 @@ const message1 = {
         }
     }
 };
-const hub = {
-    parameterPath: "hub",
+const accept2 = {
+    parameterPath: "accept",
     mapper: {
-        serializedName: "hub",
-        required: true,
+        defaultValue: "application/json, text/json",
+        isConstant: true,
+        serializedName: "Accept",
         type: {
             name: "String"
         }
     }
 };
-const excluded = {
-    parameterPath: ["options", "excluded"],
+const excludedConnections = {
+    parameterPath: ["options", "excludedConnections"],
     mapper: {
         serializedName: "excluded",
         type: {
@@ -99,11 +595,14 @@ const excluded = {
             }
         }
     },
-    collectionFormat: coreHttp.QueryCollectionFormat.Multi
+    collectionFormat: "Multi"
 };
 const connectionId = {
     parameterPath: "connectionId",
     mapper: {
+        constraints: {
+            MinLength: 1
+        },
         serializedName: "connectionId",
         required: true,
         type: {
@@ -111,18 +610,13 @@ const connectionId = {
         }
     }
 };
-const reason = {
-    parameterPath: ["options", "reason"],
-    mapper: {
-        serializedName: "reason",
-        type: {
-            name: "String"
-        }
-    }
-};
 const group = {
     parameterPath: "group",
     mapper: {
+        constraints: {
+            MaxLength: 1024,
+            MinLength: 1
+        },
         serializedName: "group",
         required: true,
         type: {
@@ -130,9 +624,12 @@ const group = {
         }
     }
 };
-const userId = {
+const userId1 = {
     parameterPath: "userId",
     mapper: {
+        constraints: {
+            MinLength: 1
+        },
         serializedName: "userId",
         required: true,
         type: {
@@ -159,29 +656,16 @@ const targetName = {
         }
     }
 };
-const permission1 = {
-    parameterPath: "permission",
-    mapper: {
-        serializedName: "permission",
-        required: true,
-        type: {
-            name: "String"
-        }
-    }
-};
-const permission2 = {
-    parameterPath: "permission",
-    mapper: {
-        serializedName: "permission",
-        required: true,
-        type: {
-            name: "String"
-        }
-    }
-};
 
-/** Class representing a HealthApi. */
-class HealthApi {
+/*
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ *
+ * Code generated by Microsoft (R) AutoRest Code Generator.
+ * Changes may cause incorrect behavior and will be lost if the code is regenerated.
+ */
+/** Class containing HealthApi operations. */
+class HealthApiImpl {
     /**
      * Initialize a new instance of the class HealthApi class.
      * @param client Reference to the service client
@@ -193,26 +677,30 @@ class HealthApi {
      * Get service health status.
      * @param options The options parameters.
      */
-    getHealthStatus(options) {
-        const operationArguments = {
-            options: coreHttp.operationOptionsToRequestOptionsBase(options || {})
-        };
-        return this.client.sendOperationRequest(operationArguments, getHealthStatusOperationSpec);
+    getServiceStatus(options) {
+        return this.client.sendOperationRequest({ options }, getServiceStatusOperationSpec);
     }
 }
 // Operation Specifications
-const serializer = new coreHttp.Serializer({}, /* isXml */ false);
-const getHealthStatusOperationSpec = {
+const serializer = coreClient.createSerializer(Mappers, /* isXml */ false);
+const getServiceStatusOperationSpec = {
     path: "/api/health",
     httpMethod: "HEAD",
     responses: { 200: {}, default: {} },
     queryParameters: [apiVersion],
-    urlParameters: [$host],
+    urlParameters: [endpoint],
     serializer
 };
 
-/** Class representing a WebPubSub. */
-class WebPubSub {
+/*
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ *
+ * Code generated by Microsoft (R) AutoRest Code Generator.
+ * Changes may cause incorrect behavior and will be lost if the code is regenerated.
+ */
+/** Class containing WebPubSub operations. */
+class WebPubSubImpl {
     /**
      * Initialize a new instance of the class WebPubSub class.
      * @param client Reference to the service client
@@ -220,6 +708,24 @@ class WebPubSub {
     constructor(client) {
         this.client = client;
     }
+    /**
+     * Generate token for the client to connect Azure Web PubSub service.
+     * @param hub Target hub name, which should start with alphabetic characters and only contain
+     *            alpha-numeric characters or underscore.
+     * @param options The options parameters.
+     */
+    generateClientToken(hub, options) {
+        return this.client.sendOperationRequest({ hub, options }, generateClientTokenOperationSpec);
+    }
+    /**
+     * Close the connections in the hub.
+     * @param hub Target hub name, which should start with alphabetic characters and only contain
+     *            alpha-numeric characters or underscore.
+     * @param options The options parameters.
+     */
+    closeAllConnections(hub, options) {
+        return this.client.sendOperationRequest({ hub, options }, closeAllConnectionsOperationSpec);
+    }
     /**
      * Broadcast content inside request body to all the connected client connections.
      * @param args Includes all the parameters for this operation.
@@ -252,7 +758,7 @@ class WebPubSub {
         else {
             throw new TypeError(`"contentType" must be a valid value but instead was "${args[1]}".`);
         }
-        operationArguments.options = coreHttp.operationOptionsToRequestOptionsBase(options || {});
+        operationArguments.options = options || {};
         return this.client.sendOperationRequest(operationArguments, operationSpec);
     }
     /**
@@ -263,12 +769,7 @@ class WebPubSub {
      * @param options The options parameters.
      */
     connectionExists(hub, connectionId, options) {
-        const operationArguments = {
-            hub,
-            connectionId,
-            options: coreHttp.operationOptionsToRequestOptionsBase(options || {})
-        };
-        return this.client.sendOperationRequest(operationArguments, connectionExistsOperationSpec);
+        return this.client.sendOperationRequest({ hub, connectionId, options }, connectionExistsOperationSpec);
     }
     /**
      * Close the client connection.
@@ -277,13 +778,8 @@ class WebPubSub {
      * @param connectionId Target connection Id.
      * @param options The options parameters.
      */
-    closeClientConnection(hub, connectionId, options) {
-        const operationArguments = {
-            hub,
-            connectionId,
-            options: coreHttp.operationOptionsToRequestOptionsBase(options || {})
-        };
-        return this.client.sendOperationRequest(operationArguments, closeClientConnectionOperationSpec);
+    closeConnection(hub, connectionId, options) {
+        return this.client.sendOperationRequest({ hub, connectionId, options }, closeConnectionOperationSpec);
     }
     /**
      * Send content inside request body to the specific connection.
@@ -319,7 +815,7 @@ class WebPubSub {
         else {
             throw new TypeError(`"contentType" must be a valid value but instead was "${args[2]}".`);
         }
-        operationArguments.options = coreHttp.operationOptionsToRequestOptionsBase(options || {});
+        operationArguments.options = options || {};
         return this.client.sendOperationRequest(operationArguments, operationSpec);
     }
     /**
@@ -330,12 +826,17 @@ class WebPubSub {
      * @param options The options parameters.
      */
     groupExists(hub, group, options) {
-        const operationArguments = {
-            hub,
-            group,
-            options: coreHttp.operationOptionsToRequestOptionsBase(options || {})
-        };
-        return this.client.sendOperationRequest(operationArguments, groupExistsOperationSpec);
+        return this.client.sendOperationRequest({ hub, group, options }, groupExistsOperationSpec);
+    }
+    /**
+     * Close connections in the specific group.
+     * @param hub Target hub name, which should start with alphabetic characters and only contain
+     *            alpha-numeric characters or underscore.
+     * @param group Target group name, which length should be greater than 0 and less than 1025.
+     * @param options The options parameters.
+     */
+    closeGroupConnections(hub, group, options) {
+        return this.client.sendOperationRequest({ hub, group, options }, closeGroupConnectionsOperationSpec);
     }
     /**
      * Send content inside request body to a group of connections.
@@ -371,7 +872,7 @@ class WebPubSub {
         else {
             throw new TypeError(`"contentType" must be a valid value but instead was "${args[2]}".`);
         }
-        operationArguments.options = coreHttp.operationOptionsToRequestOptionsBase(options || {});
+        operationArguments.options = options || {};
         return this.client.sendOperationRequest(operationArguments, operationSpec);
     }
     /**
@@ -383,13 +884,7 @@ class WebPubSub {
      * @param options The options parameters.
      */
     addConnectionToGroup(hub, group, connectionId, options) {
-        const operationArguments = {
-            hub,
-            group,
-            connectionId,
-            options: coreHttp.operationOptionsToRequestOptionsBase(options || {})
-        };
-        return this.client.sendOperationRequest(operationArguments, addConnectionToGroupOperationSpec);
+        return this.client.sendOperationRequest({ hub, group, connectionId, options }, addConnectionToGroupOperationSpec);
     }
     /**
      * Remove a connection from the target group.
@@ -400,28 +895,27 @@ class WebPubSub {
      * @param options The options parameters.
      */
     removeConnectionFromGroup(hub, group, connectionId, options) {
-        const operationArguments = {
-            hub,
-            group,
-            connectionId,
-            options: coreHttp.operationOptionsToRequestOptionsBase(options || {})
-        };
-        return this.client.sendOperationRequest(operationArguments, removeConnectionFromGroupOperationSpec);
+        return this.client.sendOperationRequest({ hub, group, connectionId, options }, removeConnectionFromGroupOperationSpec);
+    }
+    /**
+     * Check if there are any client connections connected for the given user.
+     * @param hub Target hub name, which should start with alphabetic characters and only contain
+     *            alpha-numeric characters or underscore.
+     * @param userId Target user Id.
+     * @param options The options parameters.
+     */
+    userExists(hub, userId, options) {
+        return this.client.sendOperationRequest({ hub, userId, options }, userExistsOperationSpec);
     }
     /**
-     * Check if there are any client connections connected for the given user.
+     * Close connections for the specific user.
      * @param hub Target hub name, which should start with alphabetic characters and only contain
      *            alpha-numeric characters or underscore.
-     * @param userId Target user Id.
+     * @param userId The user Id.
      * @param options The options parameters.
      */
-    userExists(hub, userId, options) {
-        const operationArguments = {
-            hub,
-            userId,
-            options: coreHttp.operationOptionsToRequestOptionsBase(options || {})
-        };
-        return this.client.sendOperationRequest(operationArguments, userExistsOperationSpec);
+    closeUserConnections(hub, userId, options) {
+        return this.client.sendOperationRequest({ hub, userId, options }, closeUserConnectionsOperationSpec);
     }
     /**
      * Send content inside request body to the specific user.
@@ -457,26 +951,9 @@ class WebPubSub {
         else {
             throw new TypeError(`"contentType" must be a valid value but instead was "${args[2]}".`);
         }
-        operationArguments.options = coreHttp.operationOptionsToRequestOptionsBase(options || {});
+        operationArguments.options = options || {};
         return this.client.sendOperationRequest(operationArguments, operationSpec);
     }
-    /**
-     * Check whether a user exists in the target group.
-     * @param hub Target hub name, which should start with alphabetic characters and only contain
-     *            alpha-numeric characters or underscore.
-     * @param group Target group name, which length should be greater than 0 and less than 1025.
-     * @param userId Target user Id.
-     * @param options The options parameters.
-     */
-    userExistsInGroup(hub, group, userId, options) {
-        const operationArguments = {
-            hub,
-            group,
-            userId,
-            options: coreHttp.operationOptionsToRequestOptionsBase(options || {})
-        };
-        return this.client.sendOperationRequest(operationArguments, userExistsInGroupOperationSpec);
-    }
     /**
      * Add a user to the target group.
      * @param hub Target hub name, which should start with alphabetic characters and only contain
@@ -486,13 +963,7 @@ class WebPubSub {
      * @param options The options parameters.
      */
     addUserToGroup(hub, group, userId, options) {
-        const operationArguments = {
-            hub,
-            group,
-            userId,
-            options: coreHttp.operationOptionsToRequestOptionsBase(options || {})
-        };
-        return this.client.sendOperationRequest(operationArguments, addUserToGroupOperationSpec);
+        return this.client.sendOperationRequest({ hub, group, userId, options }, addUserToGroupOperationSpec);
     }
     /**
      * Remove a user from the target group.
@@ -503,13 +974,7 @@ class WebPubSub {
      * @param options The options parameters.
      */
     removeUserFromGroup(hub, group, userId, options) {
-        const operationArguments = {
-            hub,
-            group,
-            userId,
-            options: coreHttp.operationOptionsToRequestOptionsBase(options || {})
-        };
-        return this.client.sendOperationRequest(operationArguments, removeUserFromGroupOperationSpec);
+        return this.client.sendOperationRequest({ hub, group, userId, options }, removeUserFromGroupOperationSpec);
     }
     /**
      * Remove a user from all groups.
@@ -519,12 +984,7 @@ class WebPubSub {
      * @param options The options parameters.
      */
     removeUserFromAllGroups(hub, userId, options) {
-        const operationArguments = {
-            hub,
-            userId,
-            options: coreHttp.operationOptionsToRequestOptionsBase(options || {})
-        };
-        return this.client.sendOperationRequest(operationArguments, removeUserFromAllGroupsOperationSpec);
+        return this.client.sendOperationRequest({ hub, userId, options }, removeUserFromAllGroupsOperationSpec);
     }
     /**
      * Grant permission to the connection.
@@ -535,13 +995,7 @@ class WebPubSub {
      * @param options The options parameters.
      */
     grantPermission(hub, permission, connectionId, options) {
-        const operationArguments = {
-            hub,
-            permission,
-            connectionId,
-            options: coreHttp.operationOptionsToRequestOptionsBase(options || {})
-        };
-        return this.client.sendOperationRequest(operationArguments, grantPermissionOperationSpec);
+        return this.client.sendOperationRequest({ hub, permission, connectionId, options }, grantPermissionOperationSpec);
     }
     /**
      * Revoke permission for the connection.
@@ -552,13 +1006,7 @@ class WebPubSub {
      * @param options The options parameters.
      */
     revokePermission(hub, permission, connectionId, options) {
-        const operationArguments = {
-            hub,
-            permission,
-            connectionId,
-            options: coreHttp.operationOptionsToRequestOptionsBase(options || {})
-        };
-        return this.client.sendOperationRequest(operationArguments, revokePermissionOperationSpec);
+        return this.client.sendOperationRequest({ hub, permission, connectionId, options }, revokePermissionOperationSpec);
     }
     /**
      * Check if a connection has permission to the specified action.
@@ -569,293 +1017,506 @@ class WebPubSub {
      * @param options The options parameters.
      */
     checkPermission(hub, permission, connectionId, options) {
-        const operationArguments = {
-            hub,
-            permission,
-            connectionId,
-            options: coreHttp.operationOptionsToRequestOptionsBase(options || {})
-        };
-        return this.client.sendOperationRequest(operationArguments, checkPermissionOperationSpec);
+        return this.client.sendOperationRequest({ hub, permission, connectionId, options }, checkPermissionOperationSpec);
     }
 }
 // Operation Specifications
-const serializer$1 = new coreHttp.Serializer({}, /* isXml */ false);
+const serializer$1 = coreClient.createSerializer(Mappers, /* isXml */ false);
+const generateClientTokenOperationSpec = {
+    path: "/api/hubs/{hub}/:generateToken",
+    httpMethod: "POST",
+    responses: {
+        200: {
+            bodyMapper: ClientTokenResponse
+        },
+        default: {
+            bodyMapper: ErrorDetail,
+            headersMapper: WebPubSubGenerateClientTokenExceptionHeaders
+        }
+    },
+    queryParameters: [
+        apiVersion,
+        userId,
+        roles,
+        expirationTimeInMinutes
+    ],
+    urlParameters: [endpoint, hub],
+    headerParameters: [accept],
+    serializer: serializer$1
+};
+const closeAllConnectionsOperationSpec = {
+    path: "/api/hubs/{hub}/:closeConnections",
+    httpMethod: "POST",
+    responses: {
+        204: {},
+        default: {
+            bodyMapper: ErrorDetail,
+            headersMapper: WebPubSubCloseAllConnectionsExceptionHeaders
+        }
+    },
+    queryParameters: [
+        apiVersion,
+        excluded,
+        reason
+    ],
+    urlParameters: [endpoint, hub],
+    headerParameters: [accept],
+    serializer: serializer$1
+};
 const sendToAll$binaryOperationSpec = {
     path: "/api/hubs/{hub}/:send",
     httpMethod: "POST",
-    responses: { 202: {}, default: {} },
+    responses: {
+        202: {},
+        default: {
+            bodyMapper: ErrorDetail,
+            headersMapper: WebPubSubSendToAllExceptionHeaders
+        }
+    },
     requestBody: message,
-    queryParameters: [apiVersion, excluded],
-    urlParameters: [$host, hub],
-    headerParameters: [contentType],
+    queryParameters: [apiVersion, excludedConnections],
+    urlParameters: [endpoint, hub],
+    headerParameters: [contentType, accept1],
     mediaType: "binary",
     serializer: serializer$1
 };
 const sendToAll$textOperationSpec = {
     path: "/api/hubs/{hub}/:send",
     httpMethod: "POST",
-    responses: { 202: {}, default: {} },
+    responses: {
+        202: {},
+        default: {
+            bodyMapper: ErrorDetail,
+            headersMapper: WebPubSubSendToAllExceptionHeaders
+        }
+    },
     requestBody: message1,
-    queryParameters: [apiVersion, excluded],
-    urlParameters: [$host, hub],
-    headerParameters: [contentType1],
+    queryParameters: [apiVersion, excludedConnections],
+    urlParameters: [endpoint, hub],
+    headerParameters: [contentType1, accept2],
     mediaType: "text",
     serializer: serializer$1
 };
 const connectionExistsOperationSpec = {
     path: "/api/hubs/{hub}/connections/{connectionId}",
     httpMethod: "HEAD",
-    responses: { 200: {}, 404: {}, default: {} },
+    responses: {
+        200: {},
+        404: {},
+        default: {
+            bodyMapper: ErrorDetail,
+            headersMapper: WebPubSubConnectionExistsExceptionHeaders
+        }
+    },
     queryParameters: [apiVersion],
-    urlParameters: [$host, hub, connectionId],
+    urlParameters: [endpoint, hub, connectionId],
+    headerParameters: [accept],
     serializer: serializer$1
 };
-const closeClientConnectionOperationSpec = {
+const closeConnectionOperationSpec = {
     path: "/api/hubs/{hub}/connections/{connectionId}",
     httpMethod: "DELETE",
-    responses: { 200: {}, default: {} },
+    responses: {
+        204: {},
+        default: {
+            bodyMapper: ErrorDetail,
+            headersMapper: WebPubSubCloseConnectionExceptionHeaders
+        }
+    },
     queryParameters: [apiVersion, reason],
-    urlParameters: [$host, hub, connectionId],
+    urlParameters: [endpoint, hub, connectionId],
+    headerParameters: [accept],
     serializer: serializer$1
 };
 const sendToConnection$binaryOperationSpec = {
     path: "/api/hubs/{hub}/connections/{connectionId}/:send",
     httpMethod: "POST",
-    responses: { 202: {}, default: {} },
+    responses: {
+        202: {},
+        default: {
+            bodyMapper: ErrorDetail,
+            headersMapper: WebPubSubSendToConnectionExceptionHeaders
+        }
+    },
     requestBody: message,
     queryParameters: [apiVersion],
-    urlParameters: [$host, hub, connectionId],
-    headerParameters: [contentType],
+    urlParameters: [endpoint, hub, connectionId],
+    headerParameters: [contentType, accept1],
     mediaType: "binary",
     serializer: serializer$1
 };
 const sendToConnection$textOperationSpec = {
     path: "/api/hubs/{hub}/connections/{connectionId}/:send",
     httpMethod: "POST",
-    responses: { 202: {}, default: {} },
+    responses: {
+        202: {},
+        default: {
+            bodyMapper: ErrorDetail,
+            headersMapper: WebPubSubSendToConnectionExceptionHeaders
+        }
+    },
     requestBody: message1,
     queryParameters: [apiVersion],
-    urlParameters: [$host, hub, connectionId],
-    headerParameters: [contentType1],
+    urlParameters: [endpoint, hub, connectionId],
+    headerParameters: [contentType1, accept2],
     mediaType: "text",
     serializer: serializer$1
 };
 const groupExistsOperationSpec = {
     path: "/api/hubs/{hub}/groups/{group}",
     httpMethod: "HEAD",
-    responses: { 200: {}, 404: {}, default: {} },
+    responses: {
+        200: {},
+        404: {},
+        default: {
+            bodyMapper: ErrorDetail,
+            headersMapper: WebPubSubGroupExistsExceptionHeaders
+        }
+    },
     queryParameters: [apiVersion],
-    urlParameters: [$host, hub, group],
+    urlParameters: [endpoint, hub, group],
+    headerParameters: [accept],
+    serializer: serializer$1
+};
+const closeGroupConnectionsOperationSpec = {
+    path: "/api/hubs/{hub}/groups/{group}/:closeConnections",
+    httpMethod: "POST",
+    responses: {
+        204: {},
+        default: {
+            bodyMapper: ErrorDetail,
+            headersMapper: WebPubSubCloseGroupConnectionsExceptionHeaders
+        }
+    },
+    queryParameters: [
+        apiVersion,
+        excluded,
+        reason
+    ],
+    urlParameters: [endpoint, hub, group],
+    headerParameters: [accept],
     serializer: serializer$1
 };
 const sendToGroup$binaryOperationSpec = {
     path: "/api/hubs/{hub}/groups/{group}/:send",
     httpMethod: "POST",
-    responses: { 202: {}, default: {} },
+    responses: {
+        202: {},
+        default: {
+            bodyMapper: ErrorDetail,
+            headersMapper: WebPubSubSendToGroupExceptionHeaders
+        }
+    },
     requestBody: message,
-    queryParameters: [apiVersion, excluded],
-    urlParameters: [$host, hub, group],
-    headerParameters: [contentType],
+    queryParameters: [apiVersion, excludedConnections],
+    urlParameters: [endpoint, hub, group],
+    headerParameters: [contentType, accept1],
     mediaType: "binary",
     serializer: serializer$1
 };
 const sendToGroup$textOperationSpec = {
     path: "/api/hubs/{hub}/groups/{group}/:send",
     httpMethod: "POST",
-    responses: { 202: {}, default: {} },
+    responses: {
+        202: {},
+        default: {
+            bodyMapper: ErrorDetail,
+            headersMapper: WebPubSubSendToGroupExceptionHeaders
+        }
+    },
     requestBody: message1,
-    queryParameters: [apiVersion, excluded],
-    urlParameters: [$host, hub, group],
-    headerParameters: [contentType1],
+    queryParameters: [apiVersion, excludedConnections],
+    urlParameters: [endpoint, hub, group],
+    headerParameters: [contentType1, accept2],
     mediaType: "text",
     serializer: serializer$1
 };
 const addConnectionToGroupOperationSpec = {
     path: "/api/hubs/{hub}/groups/{group}/connections/{connectionId}",
     httpMethod: "PUT",
-    responses: { 200: {}, 404: {}, default: {} },
+    responses: {
+        200: {},
+        404: {},
+        default: {
+            bodyMapper: ErrorDetail,
+            headersMapper: WebPubSubAddConnectionToGroupExceptionHeaders
+        }
+    },
     queryParameters: [apiVersion],
     urlParameters: [
-        $host,
+        endpoint,
         hub,
         connectionId,
         group
     ],
+    headerParameters: [accept],
     serializer: serializer$1
 };
 const removeConnectionFromGroupOperationSpec = {
     path: "/api/hubs/{hub}/groups/{group}/connections/{connectionId}",
     httpMethod: "DELETE",
-    responses: { 200: {}, 404: {}, default: {} },
+    responses: {
+        204: {},
+        default: {
+            bodyMapper: ErrorDetail,
+            headersMapper: WebPubSubRemoveConnectionFromGroupExceptionHeaders
+        }
+    },
     queryParameters: [apiVersion],
     urlParameters: [
-        $host,
+        endpoint,
         hub,
         connectionId,
         group
     ],
+    headerParameters: [accept],
     serializer: serializer$1
 };
 const userExistsOperationSpec = {
     path: "/api/hubs/{hub}/users/{userId}",
     httpMethod: "HEAD",
-    responses: { 200: {}, 404: {}, default: {} },
+    responses: {
+        200: {},
+        404: {},
+        default: {
+            bodyMapper: ErrorDetail,
+            headersMapper: WebPubSubUserExistsExceptionHeaders
+        }
+    },
     queryParameters: [apiVersion],
-    urlParameters: [$host, hub, userId],
+    urlParameters: [endpoint, hub, userId1],
+    headerParameters: [accept],
+    serializer: serializer$1
+};
+const closeUserConnectionsOperationSpec = {
+    path: "/api/hubs/{hub}/users/{userId}/:closeConnections",
+    httpMethod: "POST",
+    responses: {
+        204: {},
+        default: {
+            bodyMapper: ErrorDetail,
+            headersMapper: WebPubSubCloseUserConnectionsExceptionHeaders
+        }
+    },
+    queryParameters: [
+        apiVersion,
+        excluded,
+        reason
+    ],
+    urlParameters: [endpoint, hub, userId1],
+    headerParameters: [accept],
     serializer: serializer$1
 };
 const sendToUser$binaryOperationSpec = {
     path: "/api/hubs/{hub}/users/{userId}/:send",
     httpMethod: "POST",
-    responses: { 202: {}, default: {} },
+    responses: {
+        202: {},
+        default: {
+            bodyMapper: ErrorDetail,
+            headersMapper: WebPubSubSendToUserExceptionHeaders
+        }
+    },
     requestBody: message,
     queryParameters: [apiVersion],
-    urlParameters: [$host, hub, userId],
-    headerParameters: [contentType],
+    urlParameters: [endpoint, hub, userId1],
+    headerParameters: [contentType, accept1],
     mediaType: "binary",
     serializer: serializer$1
 };
 const sendToUser$textOperationSpec = {
     path: "/api/hubs/{hub}/users/{userId}/:send",
     httpMethod: "POST",
-    responses: { 202: {}, default: {} },
+    responses: {
+        202: {},
+        default: {
+            bodyMapper: ErrorDetail,
+            headersMapper: WebPubSubSendToUserExceptionHeaders
+        }
+    },
     requestBody: message1,
     queryParameters: [apiVersion],
-    urlParameters: [$host, hub, userId],
-    headerParameters: [contentType1],
+    urlParameters: [endpoint, hub, userId1],
+    headerParameters: [contentType1, accept2],
     mediaType: "text",
     serializer: serializer$1
 };
-const userExistsInGroupOperationSpec = {
-    path: "/api/hubs/{hub}/users/{userId}/groups/{group}",
-    httpMethod: "HEAD",
-    responses: { 200: {}, 404: {}, default: {} },
-    queryParameters: [apiVersion],
-    urlParameters: [
-        $host,
-        hub,
-        group,
-        userId
-    ],
-    serializer: serializer$1
-};
 const addUserToGroupOperationSpec = {
     path: "/api/hubs/{hub}/users/{userId}/groups/{group}",
     httpMethod: "PUT",
-    responses: { 200: {}, default: {} },
+    responses: {
+        200: {},
+        404: {},
+        default: {
+            bodyMapper: ErrorDetail,
+            headersMapper: WebPubSubAddUserToGroupExceptionHeaders
+        }
+    },
     queryParameters: [apiVersion],
     urlParameters: [
-        $host,
+        endpoint,
         hub,
         group,
-        userId
+        userId1
     ],
+    headerParameters: [accept],
     serializer: serializer$1
 };
 const removeUserFromGroupOperationSpec = {
     path: "/api/hubs/{hub}/users/{userId}/groups/{group}",
     httpMethod: "DELETE",
-    responses: { 200: {}, default: {} },
+    responses: {
+        204: {},
+        default: {
+            bodyMapper: ErrorDetail,
+            headersMapper: WebPubSubRemoveUserFromGroupExceptionHeaders
+        }
+    },
     queryParameters: [apiVersion],
     urlParameters: [
-        $host,
+        endpoint,
         hub,
         group,
-        userId
+        userId1
     ],
+    headerParameters: [accept],
     serializer: serializer$1
 };
 const removeUserFromAllGroupsOperationSpec = {
     path: "/api/hubs/{hub}/users/{userId}/groups",
     httpMethod: "DELETE",
-    responses: { 200: {}, default: {} },
+    responses: {
+        204: {},
+        default: {
+            bodyMapper: ErrorDetail,
+            headersMapper: WebPubSubRemoveUserFromAllGroupsExceptionHeaders
+        }
+    },
     queryParameters: [apiVersion],
-    urlParameters: [$host, hub, userId],
+    urlParameters: [endpoint, hub, userId1],
+    headerParameters: [accept],
     serializer: serializer$1
 };
 const grantPermissionOperationSpec = {
     path: "/api/hubs/{hub}/permissions/{permission}/connections/{connectionId}",
     httpMethod: "PUT",
-    responses: { 200: {}, default: {} },
+    responses: {
+        200: {},
+        default: {
+            bodyMapper: ErrorDetail,
+            headersMapper: WebPubSubGrantPermissionExceptionHeaders
+        }
+    },
     queryParameters: [apiVersion, targetName],
     urlParameters: [
-        $host,
+        endpoint,
         hub,
         connectionId,
         permission
     ],
+    headerParameters: [accept],
     serializer: serializer$1
 };
 const revokePermissionOperationSpec = {
     path: "/api/hubs/{hub}/permissions/{permission}/connections/{connectionId}",
     httpMethod: "DELETE",
-    responses: { 200: {}, default: {} },
+    responses: {
+        204: {},
+        default: {
+            bodyMapper: ErrorDetail,
+            headersMapper: WebPubSubRevokePermissionExceptionHeaders
+        }
+    },
     queryParameters: [apiVersion, targetName],
     urlParameters: [
-        $host,
+        endpoint,
         hub,
         connectionId,
-        permission1
+        permission
     ],
+    headerParameters: [accept],
     serializer: serializer$1
 };
 const checkPermissionOperationSpec = {
     path: "/api/hubs/{hub}/permissions/{permission}/connections/{connectionId}",
     httpMethod: "HEAD",
-    responses: { 200: {}, 404: {}, default: {} },
+    responses: {
+        200: {},
+        404: {},
+        default: {
+            bodyMapper: ErrorDetail,
+            headersMapper: WebPubSubCheckPermissionExceptionHeaders
+        }
+    },
     queryParameters: [apiVersion, targetName],
     urlParameters: [
-        $host,
+        endpoint,
         hub,
         connectionId,
-        permission2
+        permission
     ],
+    headerParameters: [accept],
     serializer: serializer$1
 };
 
-const packageName = "WebPubSub";
-const packageVersion = "1.0.0";
-/**
- * @hidden
+/*
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ *
+ * Code generated by Microsoft (R) AutoRest Code Generator.
+ * Changes may cause incorrect behavior and will be lost if the code is regenerated.
  */
-class AzureWebPubSubServiceRestAPIContext extends coreHttp.ServiceClient {
+/** @internal */
+class GeneratedClientContext extends coreClient.ServiceClient {
     /**
-     * Initializes a new instance of the AzureWebPubSubServiceRestAPIContext class.
-     * @param $host server parameter
+     * Initializes a new instance of the GeneratedClientContext class.
+     * @param endpoint HTTP or HTTPS endpoint for the Web PubSub service instance.
      * @param options The parameter options
      */
-    constructor($host, options) {
-        if ($host === undefined) {
-            throw new Error("'$host' cannot be null");
+    constructor(endpoint, options) {
+        if (endpoint === undefined) {
+            throw new Error("'endpoint' cannot be null");
         }
         // Initializing default values for options
         if (!options) {
             options = {};
         }
-        if (!options.userAgent) {
-            const defaultUserAgent = coreHttp.getDefaultUserAgentValue();
-            options.userAgent = `${packageName}/${packageVersion} ${defaultUserAgent}`;
-        }
-        super(undefined, options);
-        this.requestContentType = "application/json; charset=utf-8";
-        this.baseUri = options.endpoint || "{$host}";
+        const defaults = {
+            requestContentType: "application/json; charset=utf-8"
+        };
+        const packageDetails = `azsdk-js-web-pubsub/1.0.1`;
+        const userAgentPrefix = options.userAgentOptions && options.userAgentOptions.userAgentPrefix
+            ? `${options.userAgentOptions.userAgentPrefix} ${packageDetails}`
+            : `${packageDetails}`;
+        const optionsWithDefaults = Object.assign(Object.assign(Object.assign({}, defaults), options), { userAgentOptions: {
+                userAgentPrefix
+            }, baseUri: options.endpoint || "{Endpoint}" });
+        super(optionsWithDefaults);
         // Parameter assignments
-        this.$host = $host;
+        this.endpoint = endpoint;
         // Assigning values to Constant parameters
-        this.apiVersion = options.apiVersion || "2020-10-01";
+        this.apiVersion = options.apiVersion || "2021-10-01";
     }
 }
 
-class AzureWebPubSubServiceRestAPI extends AzureWebPubSubServiceRestAPIContext {
+/*
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ *
+ * Code generated by Microsoft (R) AutoRest Code Generator.
+ * Changes may cause incorrect behavior and will be lost if the code is regenerated.
+ */
+/** @internal */
+class GeneratedClient extends GeneratedClientContext {
     /**
-     * Initializes a new instance of the AzureWebPubSubServiceRestAPI class.
-     * @param $host server parameter
+     * Initializes a new instance of the GeneratedClient class.
+     * @param endpoint HTTP or HTTPS endpoint for the Web PubSub service instance.
      * @param options The parameter options
      */
-    constructor($host, options) {
-        super($host, options);
-        this.healthApi = new HealthApi(this);
-        this.webPubSub = new WebPubSub(this);
+    constructor(endpoint, options) {
+        super(endpoint, options);
+        this.healthApi = new HealthApiImpl(this);
+        this.webPubSub = new WebPubSubImpl(this);
     }
 }
 
@@ -867,12 +1528,8 @@ const createSpan = coreTracing.createSpanFunction({
 });
 
 // Copyright (c) Microsoft Corporation.
-function normalizeSendToAllOptions(options) {
-    const { excludedConnections } = options, otherOptions = tslib.__rest(options, ["excludedConnections"]);
-    return Object.assign(Object.assign({}, otherOptions), { excluded: excludedConnections });
-}
-
-function isHttpRequestBody(obj) {
+// Licensed under the MIT license.
+function isRequestBody(obj) {
     return (typeof obj === "function" ||
         (typeof obj === "object" &&
             obj != null &&
@@ -880,18 +1537,18 @@ function isHttpRequestBody(obj) {
                 obj.constructor.name === "Blob" ||
                 ArrayBuffer.isView(obj))));
 }
-function getContentTypeForMessage(message, options) {
+function getPayloadForMessage(message, options) {
     if ((options === null || options === void 0 ? void 0 : options.contentType) === "text/plain") {
         if (typeof message !== "string") {
             throw new TypeError("Message must be a string.");
         }
-        return "text/plain";
+        return { contentType: "text/plain", payload: message };
     }
-    else if (isHttpRequestBody(message)) {
-        return "application/octet-stream";
+    else if (isRequestBody(message)) {
+        return { contentType: "application/octet-stream", payload: message };
     }
     else {
-        return "application/json";
+        return { contentType: "application/json", payload: JSON.stringify(message) };
     }
 }
 
@@ -901,7 +1558,6 @@ function getContentTypeForMessage(message, options) {
  */
 class WebPubSubGroupImpl {
     /**
-     * @private
      * @internal
      */
     constructor(client, hubName, groupName) {
@@ -916,150 +1572,137 @@ class WebPubSubGroupImpl {
     /**
      * Add a specific connection to this group
      *
-     * @param connectionId The connection id to add to this group
-     * @param options Additional options
+     * @param connectionId - The connection id to add to this group
+     * @param options - Additional options
      */
-    addConnection(connectionId, options = {}) {
-        return tslib.__awaiter(this, void 0, void 0, function* () {
-            const { span, updatedOptions } = createSpan("WebPubSubServiceClient-group-addConnection", options);
-            try {
-                const res = yield this.client.webPubSub.addConnectionToGroup(this.hubName, this.groupName, connectionId, updatedOptions);
-                if (res._response.status === 404) {
-                    throw new coreHttp.RestError(`Connection id '${connectionId}' doesn't exist`, undefined, res._response.status, res._response.request, res._response);
-                }
-                return res;
+    async addConnection(connectionId, options = {}) {
+        const { span, updatedOptions } = createSpan("WebPubSubServiceClient-group-addConnection", options);
+        let response;
+        function onResponse(rawResponse, flatResponse) {
+            response = rawResponse;
+            if (updatedOptions.onResponse) {
+                updatedOptions.onResponse(rawResponse, flatResponse);
             }
-            finally {
-                span.end();
+        }
+        try {
+            await this.client.webPubSub.addConnectionToGroup(this.hubName, this.groupName, connectionId, Object.assign(Object.assign({}, updatedOptions), { onResponse }));
+            if (response.status === 404) {
+                throw new coreRestPipeline.RestError(`Connection id '${connectionId}' doesn't exist`, {
+                    statusCode: response === null || response === void 0 ? void 0 : response.status,
+                    request: response === null || response === void 0 ? void 0 : response.request,
+                    response: response
+                });
             }
-        });
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Remove a specific connection from this group
      *
-     * @param connectionId The connection id to remove from this group
-     * @param options Additional options
+     * @param connectionId - The connection id to remove from this group
+     * @param options - Additional options
      */
-    removeConnection(connectionId, options = {}) {
-        return tslib.__awaiter(this, void 0, void 0, function* () {
-            const { span, updatedOptions } = createSpan("WebPubSubServiceClient-group-removeConnection", options);
-            try {
-                const res = yield this.client.webPubSub.removeConnectionFromGroup(this.hubName, this.groupName, connectionId, updatedOptions);
-                return res;
-            }
-            finally {
-                span.end();
-            }
-        });
+    async removeConnection(connectionId, options = {}) {
+        const { span, updatedOptions } = createSpan("WebPubSubServiceClient-group-removeConnection", options);
+        try {
+            await this.client.webPubSub.removeConnectionFromGroup(this.hubName, this.groupName, connectionId, updatedOptions);
+        }
+        finally {
+            span.end();
+        }
     }
     /**
-     * Add a user to this group
+     * Close all connections to this group
      *
-     * @param username The user name to add
-     * @param options Additional options
+     * @param options - Additional options
      */
-    addUser(username, options = {}) {
-        return tslib.__awaiter(this, void 0, void 0, function* () {
-            const { span, updatedOptions } = createSpan("WebPubSubServiceClient-group-addUser", options);
-            try {
-                return yield this.client.webPubSub.addUserToGroup(this.hubName, this.groupName, username, updatedOptions);
-            }
-            finally {
-                span.end();
-            }
-        });
+    async closeAllConnections(options = {}) {
+        const { span, updatedOptions } = createSpan("WebPubSubServiceClient-group-closeAllConnections", options);
+        try {
+            return await this.client.webPubSub.closeGroupConnections(this.hubName, this.groupName, updatedOptions);
+        }
+        finally {
+            span.end();
+        }
     }
     /**
-     * Check if a user is in this group
+     * Add a user to this group
      *
-     * @param username The user name to check for
-     * @param options Additional options
+     * @param username - The user name to add
+     * @param options - Additional options
      */
-    hasUser(username, options = {}) {
-        return tslib.__awaiter(this, void 0, void 0, function* () {
-            const { span, updatedOptions } = createSpan("WebPubSubServiceClient-group-hasUser", options);
-            try {
-                const res = yield this.client.webPubSub.userExistsInGroup(this.hubName, this.groupName, username, updatedOptions);
-                if (res._response.status === 200) {
-                    return true;
-                }
-                else if (res._response.status === 404) {
-                    return false;
-                }
-                else {
-                    // this is sad - wish this was handled by autorest.
-                    throw new coreHttp.RestError(res._response.bodyAsText, undefined, res._response.status, res._response.request, res._response);
-                }
-            }
-            finally {
-                span.end();
-            }
-        });
+    async addUser(username, options = {}) {
+        const { span, updatedOptions } = createSpan("WebPubSubServiceClient-group-addUser", options);
+        try {
+            await this.client.webPubSub.addUserToGroup(this.hubName, this.groupName, username, updatedOptions);
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Remove a user from this group
      *
-     * @param username The user name to remove
-     * @param options Additional options
+     * @param username - The user name to remove
+     * @param options - Additional options
      */
-    removeUser(username, options = {}) {
-        return tslib.__awaiter(this, void 0, void 0, function* () {
-            const { span, updatedOptions } = createSpan("WebPubSubServiceClient-group-removeUser", options);
-            try {
-                return yield this.client.webPubSub.removeUserFromGroup(this.hubName, this.groupName, username, updatedOptions);
-            }
-            finally {
-                span.end();
-            }
-        });
-    }
-    sendToAll(message, options = {}) {
-        return tslib.__awaiter(this, void 0, void 0, function* () {
-            const normalizedOptions = normalizeSendToAllOptions(options);
-            const { span, updatedOptions } = createSpan("WebPubSubServiceClient-group-sendToAll", normalizedOptions);
-            const contentType = getContentTypeForMessage(message, updatedOptions);
-            try {
-                return yield this.client.webPubSub.sendToGroup(this.hubName, this.groupName, contentType, contentType === "application/json" ? JSON.stringify(message) : message, updatedOptions);
-            }
-            finally {
-                span.end();
-            }
-        });
+    async removeUser(username, options = {}) {
+        const { span, updatedOptions } = createSpan("WebPubSubServiceClient-group-removeUser", options);
+        try {
+            await this.client.webPubSub.removeUserFromGroup(this.hubName, this.groupName, username, updatedOptions);
+        }
+        finally {
+            span.end();
+        }
+    }
+    async sendToAll(message, options = {}) {
+        const { span, updatedOptions } = createSpan("WebPubSubServiceClient-group-sendToAll", options);
+        const { contentType, payload } = getPayloadForMessage(message, updatedOptions);
+        try {
+            await this.client.webPubSub.sendToGroup(this.hubName, this.groupName, contentType, payload, updatedOptions);
+        }
+        finally {
+            span.end();
+        }
     }
 }
 
 // Copyright (c) Microsoft Corporation.
-function webPubSubAzureKeyCredentialPolicyFactory(credential) {
+/**
+ * The programmatic identifier of the webPubSubKeyCredentialPolicy.
+ */
+const webPubSubKeyCredentialPolicyName = "webPubSubKeyCredentialPolicy";
+/**
+ * Create an HTTP pipeline policy to authenticate a request
+ * using an `AzureKeyCredential` for Text Analytics
+ * @internal
+ */
+function webPubSubKeyCredentialPolicy(credential) {
     return {
-        create: (nextPolicy, options) => {
-            return new WebPubSubKeyCredentialPolicy(nextPolicy, options, credential);
-        }
-    };
-}
-class WebPubSubKeyCredentialPolicy extends coreHttp.BaseRequestPolicy {
-    constructor(nextPolicy, options, credential) {
-        super(nextPolicy, options);
-        this.credential = credential;
-    }
-    sendRequest(request) {
-        request.headers.set("Authorization", "Bearer " +
-            jwt.sign({}, this.credential.key, {
+        name: webPubSubKeyCredentialPolicyName,
+        sendRequest(request, next) {
+            const bearerToken = jwt.sign({}, credential.key, {
                 audience: request.url,
                 expiresIn: "1h",
                 algorithm: "HS256"
-            }));
-        return this._nextPolicy.sendRequest(request);
-    }
+            });
+            request.headers.set("Authorization", `Bearer ${bearerToken}`);
+            return next(request);
+        }
+    };
 }
 
 // Copyright (c) Microsoft Corporation.
 /**
- * The @azure/logger configuration for this package.
+ * The `@azure/logger` configuration for this package.
  */
 const logger = logger$1.createClientLogger("web-pubsub");
 
+// Copyright (c) Microsoft Corporation.
 function parseConnectionString(conn) {
-    let parsed = {};
+    const parsed = {};
     conn.split(";").forEach((i) => {
         const assignmentPos = i.indexOf("=");
         if (assignmentPos === -1)
@@ -1086,22 +1729,44 @@ function parseConnectionString(conn) {
     return { credential, endpoint };
 }
 
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+const webPubSubReverseProxyPolicyName = "webPubSubReverseProxyPolicy";
+/**
+ * Create an HTTP pipeline policy to use a reverse proxy.
+ * This is generally going to be an Azure APIM endpoint.
+ * @internal
+ */
+function webPubSubReverseProxyPolicy(endpoint) {
+    const rpEndpointUrl = new URL(endpoint);
+    return {
+        name: webPubSubReverseProxyPolicyName,
+        sendRequest(request, next) {
+            const parsedUrl = new URL(request.url);
+            parsedUrl.host = rpEndpointUrl.host;
+            request.url = parsedUrl.toString();
+            return next(request);
+        }
+    };
+}
+
 // Copyright (c) Microsoft Corporation.
 /**
  * Client for connecting to a Web PubSub hub
  */
 class WebPubSubServiceClient {
     constructor(endpointOrConnectionString, credsOrHubName, hubNameOrOpts, opts) {
+        var _a, _b;
         /**
          * The Web PubSub API version being used by this client
          */
-        this.apiVersion = "2020-10-01";
+        this.apiVersion = "2021-10-01";
         // unpack constructor arguments
-        if (typeof credsOrHubName === "object" && "key" in credsOrHubName) {
+        if (typeof credsOrHubName === "object") {
             this.endpoint = endpointOrConnectionString;
-            this.credential = credsOrHubName;
             this.hubName = hubNameOrOpts;
             this.clientOptions = opts;
+            this.credential = credsOrHubName;
         }
         else {
             const parsedCs = parseConnectionString(endpointOrConnectionString);
@@ -1110,254 +1775,337 @@ class WebPubSubServiceClient {
             this.hubName = credsOrHubName;
             this.clientOptions = hubNameOrOpts;
         }
-        const internalPipelineOptions = Object.assign(Object.assign({}, this.clientOptions), {
+        const internalPipelineOptions = Object.assign(Object.assign(Object.assign({}, this.clientOptions), {
+            apiVersion: this.apiVersion,
             loggingOptions: {
                 logger: logger.info
             }
-        });
-        const pipeline = coreHttp.createPipelineFromOptions(internalPipelineOptions, webPubSubAzureKeyCredentialPolicyFactory(this.credential));
-        this.client = new AzureWebPubSubServiceRestAPI(this.endpoint, pipeline);
-    }
-    /**
-     * Auth the client connection with userId and custom claims if any
-     * @param options The options that the client has
-     */
-    getAuthenticationToken(options) {
-        return tslib.__awaiter(this, void 0, void 0, function* () {
-            const endpoint = this.endpoint.endsWith("/") ? this.endpoint : this.endpoint + "/";
-            const key = this.credential.key;
-            const hub = this.hubName;
-            const clientEndpoint = endpoint.replace(/(http)(s?:\/\/)/gi, "ws$2");
-            const clientUrl = `${clientEndpoint}client/hubs/${hub}`;
-            const audience = `${endpoint}client/hubs/${hub}`;
-            const payload = { role: options === null || options === void 0 ? void 0 : options.roles };
-            const signOptions = {
-                audience: audience,
-                expiresIn: (options === null || options === void 0 ? void 0 : options.ttl) === undefined ? "1h" : `${options.ttl}m`,
-                algorithm: "HS256"
-            };
-            if (options === null || options === void 0 ? void 0 : options.userId) {
-                signOptions.subject = options === null || options === void 0 ? void 0 : options.userId;
+        }), (coreAuth.isTokenCredential(this.credential)
+            ? {
+                credential: this.credential,
+                credentialScopes: ["https://webpubsub.azure.com/.default"]
             }
-            const token = jwt.sign(payload, key, signOptions);
-            const url = `${clientUrl}?access_token=${token}`;
-            return {
-                baseUrl: clientUrl,
-                token: jwt.sign(payload, key, signOptions),
-                url: url
-            };
-        });
+            : {}));
+        this.client = new GeneratedClient(this.endpoint, internalPipelineOptions);
+        if (!coreAuth.isTokenCredential(this.credential)) {
+            this.client.pipeline.addPolicy(webPubSubKeyCredentialPolicy(this.credential));
+        }
+        if ((_a = this.clientOptions) === null || _a === void 0 ? void 0 : _a.reverseProxyEndpoint) {
+            this.client.pipeline.addPolicy(webPubSubReverseProxyPolicy((_b = this.clientOptions) === null || _b === void 0 ? void 0 : _b.reverseProxyEndpoint));
+        }
     }
     /**
      * Get a client for a group
-     * @param groupName The name of the group to connect to.
+     * @param groupName - The name of the group to connect to.
      */
     group(groupName) {
         return new WebPubSubGroupImpl(this.client, this.hubName, groupName);
     }
-    sendToAll(message, options = {}) {
-        return tslib.__awaiter(this, void 0, void 0, function* () {
-            const normalizedOptions = normalizeSendToAllOptions(options);
-            const { span, updatedOptions } = createSpan("WebPubSubServiceClient-hub-sendToAll", normalizedOptions);
-            const contentType = getContentTypeForMessage(message, updatedOptions);
-            try {
-                return yield this.client.webPubSub.sendToAll(this.hubName, contentType, contentType === "application/json" ? JSON.stringify(message) : message, updatedOptions);
-            }
-            finally {
-                span.end();
-            }
-        });
-    }
-    sendToUser(username, message, options = {}) {
-        return tslib.__awaiter(this, void 0, void 0, function* () {
-            const { span, updatedOptions } = createSpan("WebPubSubServiceClient-hub-sendToUser", options);
-            const contentType = getContentTypeForMessage(message, updatedOptions);
-            try {
-                return yield this.client.webPubSub.sendToUser(this.hubName, username, contentType, contentType === "application/json" ? JSON.stringify(message) : message, updatedOptions);
-            }
-            finally {
-                span.end();
-            }
-        });
-    }
-    sendToConnection(connectionId, message, options = {}) {
-        return tslib.__awaiter(this, void 0, void 0, function* () {
-            const { span, updatedOptions } = createSpan("WebPubSubServiceClient-hub-sendToConnection", options);
-            const contentType = getContentTypeForMessage(message, updatedOptions);
-            try {
-                return yield this.client.webPubSub.sendToConnection(this.hubName, connectionId, contentType, contentType === "application/json" ? JSON.stringify(message) : message, updatedOptions);
-            }
-            finally {
-                span.end();
-            }
-        });
+    async sendToAll(message, options = {}) {
+        const { span, updatedOptions } = createSpan("WebPubSubServiceClient-hub-sendToAll", options);
+        const { contentType, payload } = getPayloadForMessage(message, updatedOptions);
+        try {
+            return await this.client.webPubSub.sendToAll(this.hubName, contentType, payload, updatedOptions);
+        }
+        finally {
+            span.end();
+        }
+    }
+    async sendToUser(username, message, options = {}) {
+        const { span, updatedOptions } = createSpan("WebPubSubServiceClient-hub-sendToUser", options);
+        const { contentType, payload } = getPayloadForMessage(message, updatedOptions);
+        try {
+            return await this.client.webPubSub.sendToUser(this.hubName, username, contentType, payload, updatedOptions);
+        }
+        finally {
+            span.end();
+        }
+    }
+    async sendToConnection(connectionId, message, options = {}) {
+        const { span, updatedOptions } = createSpan("WebPubSubServiceClient-hub-sendToConnection", options);
+        const { contentType, payload } = getPayloadForMessage(message, updatedOptions);
+        try {
+            return await this.client.webPubSub.sendToConnection(this.hubName, connectionId, contentType, payload, updatedOptions);
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Check if a specific connection is connected to this hub
      *
-     * @param connectionId Connection id to check
-     * @param options Additional options
+     * @param connectionId - Connection id to check
+     * @param options - Additional options
      */
-    hasConnection(connectionId, options = {}) {
-        return tslib.__awaiter(this, void 0, void 0, function* () {
-            const { span, updatedOptions } = createSpan("WebPubSubServiceClient-hub-hasConnection", options);
-            try {
-                const res = yield this.client.webPubSub.connectionExists(this.hubName, connectionId, updatedOptions);
-                if (res._response.status === 200) {
-                    return true;
-                }
-                else if (res._response.status === 404) {
-                    return false;
-                }
-                else {
-                    // this is sad - wish this was handled by autorest.
-                    throw new coreHttp.RestError(res._response.bodyAsText, undefined, res._response.status, res._response.request, res._response);
-                }
+    async connectionExists(connectionId, options = {}) {
+        const { span, updatedOptions } = createSpan("WebPubSubServiceClient-hub-hasConnection", options);
+        let response;
+        function onResponse(rawResponse, flatResponse) {
+            response = rawResponse;
+            if (updatedOptions.onResponse) {
+                updatedOptions.onResponse(rawResponse, flatResponse);
+            }
+        }
+        try {
+            await this.client.webPubSub.connectionExists(this.hubName, connectionId, Object.assign(Object.assign({}, updatedOptions), { onResponse }));
+            if (response.status === 200) {
+                return true;
+            }
+            else if (response.status === 404) {
+                return false;
             }
-            finally {
-                span.end();
+            else {
+                // this is sad - wish this was handled by autorest.
+                throw new coreRestPipeline.RestError(response.bodyAsText, {
+                    statusCode: response === null || response === void 0 ? void 0 : response.status,
+                    request: response === null || response === void 0 ? void 0 : response.request,
+                    response: response
+                });
             }
-        });
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Close a specific connection to this hub
      *
-     * @param connectionId Connection id to close
-     * @param options Additional options
+     * @param connectionId - Connection id to close
+     * @param options - Additional options
      */
-    closeConnection(connectionId, options = {}) {
-        return tslib.__awaiter(this, void 0, void 0, function* () {
-            const { span, updatedOptions } = createSpan("WebPubSubServiceClient-hub-removeConnection", options);
-            try {
-                return yield this.client.webPubSub.closeClientConnection(this.hubName, connectionId, updatedOptions);
-            }
-            finally {
-                span.end();
-            }
-        });
+    async closeConnection(connectionId, options = {}) {
+        const { span, updatedOptions } = createSpan("WebPubSubServiceClient-hub-closeConnection", options);
+        try {
+            return await this.client.webPubSub.closeConnection(this.hubName, connectionId, updatedOptions);
+        }
+        finally {
+            span.end();
+        }
+    }
+    /**
+     * Close all connections to this hub
+     *
+     * @param options - Additional options
+     */
+    async closeAllConnections(options = {}) {
+        const { span, updatedOptions } = createSpan("WebPubSubServiceClient-hub-closeAllConnections", options);
+        try {
+            return await this.client.webPubSub.closeAllConnections(this.hubName, updatedOptions);
+        }
+        finally {
+            span.end();
+        }
+    }
+    /**
+     * Close all connections with the given user id
+     *
+     * @param user - User id to close
+     * @param options - Additional options
+     */
+    async closeUserConnections(userId, options = {}) {
+        const { span, updatedOptions } = createSpan("WebPubSubServiceClient-hub-closeUserConnections", options);
+        try {
+            return await this.client.webPubSub.closeUserConnections(this.hubName, userId, updatedOptions);
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Remove a specific user from all groups they are joined to
-     * @param userId The user id to remove from all groups
-     * @param options Additional options
+     * @param userId - The user id to remove from all groups
+     * @param options - Additional options
      */
-    removeUserFromAllGroups(userId, options = {}) {
-        return tslib.__awaiter(this, void 0, void 0, function* () {
-            const { span, updatedOptions } = createSpan("WebPubSubServiceClient-hub-removeUserFromAllGroups", options);
-            try {
-                return yield this.client.webPubSub.removeUserFromAllGroups(this.hubName, userId, updatedOptions);
-            }
-            finally {
-                span.end();
-            }
-        });
+    async removeUserFromAllGroups(userId, options = {}) {
+        const { span, updatedOptions } = createSpan("WebPubSubServiceClient-hub-removeUserFromAllGroups", options);
+        try {
+            await this.client.webPubSub.removeUserFromAllGroups(this.hubName, userId, updatedOptions);
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Check if a particular group exists (i.e. has active connections).
      *
-     * @param groupName The group name to check for
-     * @param options Additional options
+     * @param groupName - The group name to check for
+     * @param options - Additional options
      */
-    hasGroup(groupName, options = {}) {
-        return tslib.__awaiter(this, void 0, void 0, function* () {
-            const { span, updatedOptions } = createSpan("WebPubSubServiceClient-hub-hasGroup", options);
-            try {
-                const res = yield this.client.webPubSub.groupExists(this.hubName, groupName, updatedOptions);
-                if (res._response.status === 200) {
-                    return true;
-                }
-                else if (res._response.status === 404) {
-                    return false;
-                }
-                else {
-                    throw new coreHttp.RestError(res._response.bodyAsText, undefined, res._response.status, res._response.request, res._response);
-                }
+    async groupExists(groupName, options = {}) {
+        const { span, updatedOptions } = createSpan("WebPubSubServiceClient-hub-hasGroup", options);
+        let response;
+        function onResponse(rawResponse, flatResponse) {
+            response = rawResponse;
+            if (updatedOptions.onResponse) {
+                updatedOptions.onResponse(rawResponse, flatResponse);
+            }
+        }
+        try {
+            await this.client.webPubSub.groupExists(this.hubName, groupName, Object.assign(Object.assign({}, updatedOptions), { onResponse }));
+            if (response.status === 200) {
+                return true;
+            }
+            else if (response.status === 404) {
+                return false;
             }
-            finally {
-                span.end();
+            else {
+                throw new coreRestPipeline.RestError(response.bodyAsText, {
+                    statusCode: response === null || response === void 0 ? void 0 : response.status,
+                    request: response === null || response === void 0 ? void 0 : response.request,
+                    response: response
+                });
             }
-        });
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Check if a particular user is connected to this hub.
      *
-     * @param username The user name to check for
-     * @param options Additional options
+     * @param username - The user name to check for
+     * @param options - Additional options
      */
-    hasUser(username, options = {}) {
-        return tslib.__awaiter(this, void 0, void 0, function* () {
-            const { span, updatedOptions } = createSpan("WebPubSubServiceClient-hub-hasUser", options);
-            try {
-                const res = yield this.client.webPubSub.userExists(this.hubName, username, updatedOptions);
-                if (res._response.status === 200) {
-                    return true;
-                }
-                else if (res._response.status === 404) {
-                    return false;
-                }
-                else {
-                    // this is sad - wish this was handled by autorest.
-                    throw new coreHttp.RestError(res._response.bodyAsText, undefined, res._response.status, res._response.request, res._response);
-                }
+    async userExists(username, options = {}) {
+        const { span, updatedOptions } = createSpan("WebPubSubServiceClient-hub-hasUser", options);
+        let response;
+        function onResponse(rawResponse, flatResponse) {
+            response = rawResponse;
+            if (updatedOptions.onResponse) {
+                updatedOptions.onResponse(rawResponse, flatResponse);
+            }
+        }
+        try {
+            await this.client.webPubSub.userExists(this.hubName, username, Object.assign(Object.assign({}, updatedOptions), { onResponse }));
+            if (response.status === 200) {
+                return true;
+            }
+            else if (response.status === 404) {
+                return false;
             }
-            finally {
-                span.end();
+            else {
+                // this is sad - wish this was handled by autorest.
+                throw new coreRestPipeline.RestError(response.bodyAsText, {
+                    statusCode: response === null || response === void 0 ? void 0 : response.status,
+                    request: response === null || response === void 0 ? void 0 : response.request,
+                    response: response
+                });
             }
-        });
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Grant permissions to a connection
      *
-     * @param connectionId The connection id to grant permissions to
-     * @param Permission The permission to grant
-     * @param options Additional options
+     * @param connectionId - The connection id to grant permissions to
+     * @param Permission - The permission to grant
+     * @param options - Additional options
      */
-    grantPermission(connectionId, permission, options = {}) {
-        return tslib.__awaiter(this, void 0, void 0, function* () {
-            const { span, updatedOptions } = createSpan("WebPubSubServiceClient-hub-grantPermission", options);
-            try {
-                return yield this.client.webPubSub.grantPermission(this.hubName, permission, connectionId, updatedOptions);
-            }
-            finally {
-                span.end();
-            }
-        });
+    async grantPermission(connectionId, permission, options = {}) {
+        const { span, updatedOptions } = createSpan("WebPubSubServiceClient-hub-grantPermission", options);
+        try {
+            return await this.client.webPubSub.grantPermission(this.hubName, permission, connectionId, updatedOptions);
+        }
+        finally {
+            span.end();
+        }
     }
     /**
      * Revoke permissions from a connection
      *
-     * @param connectionId The connection id to revoke permissions from
-     * @param Permission The permission to revoke
-     * @param options Additional options
+     * @param connectionId - The connection id to revoke permissions from
+     * @param Permission - The permission to revoke
+     * @param options - Additional options
+     */
+    async revokePermission(connectionId, permission, options = {}) {
+        const { span, updatedOptions } = createSpan("WebPubSubServiceClient-hub-revokePermission", options);
+        try {
+            return await this.client.webPubSub.revokePermission(this.hubName, permission, connectionId, updatedOptions);
+        }
+        finally {
+            span.end();
+        }
+    }
+    /**
+     * Check if the connection has the specified permission
+     *
+     * @param connectionId - The connection id to check permission
+     * @param Permission - The permission to check
+     * @param options - Additional options
      */
-    revokePermission(connectionId, permission, options = {}) {
-        return tslib.__awaiter(this, void 0, void 0, function* () {
-            const { span, updatedOptions } = createSpan("WebPubSubServiceClient-hub-revokePermission", options);
-            try {
-                return yield this.client.webPubSub.revokePermission(this.hubName, permission, connectionId, updatedOptions);
+    async hasPermission(connectionId, permission, options = {}) {
+        const { span, updatedOptions } = createSpan("WebPubSubServiceClient-hub-hasPermission", options);
+        let response;
+        function onResponse(rawResponse, flatResponse) {
+            response = rawResponse;
+            if (updatedOptions.onResponse) {
+                updatedOptions.onResponse(rawResponse, flatResponse);
+            }
+        }
+        try {
+            await this.client.webPubSub.checkPermission(this.hubName, permission, connectionId, Object.assign(Object.assign({}, updatedOptions), { onResponse }));
+            if (response.status === 200) {
+                return true;
+            }
+            else if (response.status === 404) {
+                return false;
             }
-            finally {
-                span.end();
+            else {
+                // this is sad - wish this was handled by autorest.
+                throw new coreRestPipeline.RestError(response.bodyAsText, {
+                    statusCode: response === null || response === void 0 ? void 0 : response.status,
+                    request: response === null || response === void 0 ? void 0 : response.request,
+                    response: response
+                });
             }
-        });
+        }
+        finally {
+            span.end();
+        }
     }
     /**
-     * Check if the connection has the specified permission
+     * Generate a token for a client to connect to the Azure Web PubSub service.
      *
-     * @param connectionId The connection id to check permission
-     * @param Permission The permission to check
-     * @param options Additional options
+     * @param options - Additional options
      */
-    hasPermission(connectionId, permission, options = {}) {
-        return tslib.__awaiter(this, void 0, void 0, function* () {
-            const { span, updatedOptions } = createSpan("WebPubSubServiceClient-hub-hasPermission", options);
-            try {
-                return yield this.client.webPubSub.checkPermission(this.hubName, permission, connectionId, updatedOptions);
+    async getClientAccessToken(options = {}) {
+        const { span, updatedOptions } = createSpan("WebPubSubServiceClient-hub-generateClientToken", options);
+        try {
+            const endpoint = this.endpoint.endsWith("/") ? this.endpoint : this.endpoint + "/";
+            const clientEndpoint = endpoint.replace(/(http)(s?:\/\/)/gi, "ws$2");
+            const baseUrl = `${clientEndpoint}client/hubs/${this.hubName}`;
+            let token;
+            if (coreAuth.isTokenCredential(this.credential)) {
+                const response = await this.client.webPubSub.generateClientToken(this.hubName, updatedOptions);
+                token = response.token;
             }
-            finally {
-                span.end();
+            else {
+                const key = this.credential.key;
+                const audience = `${endpoint}client/hubs/${this.hubName}`;
+                const payload = { role: options === null || options === void 0 ? void 0 : options.roles };
+                const signOptions = {
+                    audience: audience,
+                    expiresIn: (options === null || options === void 0 ? void 0 : options.expirationTimeInMinutes) === undefined
+                        ? "1h"
+                        : `${options.expirationTimeInMinutes}m`,
+                    algorithm: "HS256"
+                };
+                if (options === null || options === void 0 ? void 0 : options.userId) {
+                    signOptions.subject = options === null || options === void 0 ? void 0 : options.userId;
+                }
+                token = jwt.sign(payload, key, signOptions);
             }
-        });
+            return {
+                token,
+                baseUrl,
+                url: `${baseUrl}?access_token=${token}`
+            };
+        }
+        finally {
+            span.end();
+        }
     }
 }