{"version":3,"file":"static/js/3663_63d1ac80b6792e8aadb7.js","mappings":"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","sources":["file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-auth@1.5.0/node_modules/@azure/core-auth/dist-esm/src/azureKeyCredential.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-auth@1.5.0/node_modules/@azure/core-auth/dist-esm/src/tokenCredential.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-client@1.9.2/node_modules/@azure/core-client/dist/browser/base64.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-client@1.9.2/node_modules/@azure/core-client/dist/browser/interfaces.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-client@1.9.2/node_modules/@azure/core-client/dist/browser/utils.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-client@1.9.2/node_modules/@azure/core-client/dist/browser/serializer.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-client@1.9.2/node_modules/@azure/core-client/dist/browser/state.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-client@1.9.2/node_modules/@azure/core-client/dist/browser/operationHelpers.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-client@1.9.2/node_modules/@azure/core-client/dist/browser/deserializationPolicy.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-client@1.9.2/node_modules/@azure/core-client/dist/browser/interfaceHelpers.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-client@1.9.2/node_modules/@azure/core-client/dist/browser/serializationPolicy.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-client@1.9.2/node_modules/@azure/core-client/dist/browser/pipeline.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-client@1.9.2/node_modules/@azure/core-client/dist/browser/httpClientCache.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-client@1.9.2/node_modules/@azure/core-client/dist/browser/urlHelpers.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-client@1.9.2/node_modules/@azure/core-client/dist/browser/log.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-client@1.9.2/node_modules/@azure/core-client/dist/browser/serviceClient.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-client@1.9.2/node_modules/@azure/core-client/dist/browser/authorizeRequestOnClaimChallenge.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-client@1.9.2/node_modules/@azure/core-client/dist/browser/authorizeRequestOnTenantChallenge.js"],"sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\n/**\n * A static-key-based credential that supports updating\n * the underlying key value.\n */\nexport class AzureKeyCredential {\n    /**\n     * The value of the key to be used in authentication\n     */\n    get key() {\n        return this._key;\n    }\n    /**\n     * Create an instance of an AzureKeyCredential for use\n     * with a service client.\n     *\n     * @param key - The initial value of the key to use in authentication\n     */\n    constructor(key) {\n        if (!key) {\n            throw new Error(\"key must be a non-empty string\");\n        }\n        this._key = key;\n    }\n    /**\n     * Change the value of the key.\n     *\n     * Updates will take effect upon the next request after\n     * updating the key value.\n     *\n     * @param newKey - The new key value to be used\n     */\n    update(newKey) {\n        this._key = newKey;\n    }\n}\n//# sourceMappingURL=azureKeyCredential.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\n/**\n * Tests an object to determine whether it implements TokenCredential.\n *\n * @param credential - The assumed TokenCredential to be tested.\n */\nexport function isTokenCredential(credential) {\n    // Check for an object with a 'getToken' function and possibly with\n    // a 'signRequest' function.  We do this check to make sure that\n    // a ServiceClientCredentials implementor (like TokenClientCredentials\n    // in ms-rest-nodeauth) doesn't get mistaken for a TokenCredential if\n    // it doesn't actually implement TokenCredential also.\n    const castCredential = credential;\n    return (castCredential &&\n        typeof castCredential.getToken === \"function\" &&\n        (castCredential.signRequest === undefined || castCredential.getToken.length > 0));\n}\n//# sourceMappingURL=tokenCredential.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\n/**\n * Encodes a string in base64 format.\n * @param value - the string to encode\n * @internal\n */\nexport function encodeString(value) {\n    return btoa(value);\n}\n/**\n * Encodes a byte array in base64 format.\n * @param value - the Uint8Aray to encode\n * @internal\n */\nexport function encodeByteArray(value) {\n    let str = \"\";\n    for (let i = 0; i < value.length; i++) {\n        str += String.fromCharCode(value[i]);\n    }\n    return btoa(str);\n}\n/**\n * Decodes a base64 string into a byte array.\n * @param value - the base64 string to decode\n * @internal\n */\nexport function decodeString(value) {\n    const byteString = atob(value);\n    const arr = new Uint8Array(byteString.length);\n    for (let i = 0; i < byteString.length; i++) {\n        arr[i] = byteString.charCodeAt(i);\n    }\n    return arr;\n}\n/**\n * Decodes a base64 string into a string.\n * @param value - the base64 string to decode\n * @internal\n */\nexport function decodeStringToString(value) {\n    return atob(value);\n}\n//# sourceMappingURL=base64-browser.mjs.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\n/**\n * Default key used to access the XML attributes.\n */\nexport const XML_ATTRKEY = \"$\";\n/**\n * Default key used to access the XML value content.\n */\nexport const XML_CHARKEY = \"_\";\n//# sourceMappingURL=interfaces.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\n/**\n * A type guard for a primitive response body.\n * @param value - Value to test\n *\n * @internal\n */\nexport function isPrimitiveBody(value, mapperTypeName) {\n    return (mapperTypeName !== \"Composite\" &&\n        mapperTypeName !== \"Dictionary\" &&\n        (typeof value === \"string\" ||\n            typeof value === \"number\" ||\n            typeof value === \"boolean\" ||\n            (mapperTypeName === null || mapperTypeName === void 0 ? void 0 : mapperTypeName.match(/^(Date|DateTime|DateTimeRfc1123|UnixTime|ByteArray|Base64Url)$/i)) !==\n                null ||\n            value === undefined ||\n            value === null));\n}\nconst validateISODuration = /^(-|\\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/;\n/**\n * Returns true if the given string is in ISO 8601 format.\n * @param value - The value to be validated for ISO 8601 duration format.\n * @internal\n */\nexport function isDuration(value) {\n    return validateISODuration.test(value);\n}\nconst validUuidRegex = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/i;\n/**\n * Returns true if the provided uuid is valid.\n *\n * @param uuid - The uuid that needs to be validated.\n *\n * @internal\n */\nexport function isValidUuid(uuid) {\n    return validUuidRegex.test(uuid);\n}\n/**\n * Maps the response as follows:\n * - wraps the response body if needed (typically if its type is primitive).\n * - returns null if the combination of the headers and the body is empty.\n * - otherwise, returns the combination of the headers and the body.\n *\n * @param responseObject - a representation of the parsed response\n * @returns the response that will be returned to the user which can be null and/or wrapped\n *\n * @internal\n */\nfunction handleNullableResponseAndWrappableBody(responseObject) {\n    const combinedHeadersAndBody = Object.assign(Object.assign({}, responseObject.headers), responseObject.body);\n    if (responseObject.hasNullableType &&\n        Object.getOwnPropertyNames(combinedHeadersAndBody).length === 0) {\n        return responseObject.shouldWrapBody ? { body: null } : null;\n    }\n    else {\n        return responseObject.shouldWrapBody\n            ? Object.assign(Object.assign({}, responseObject.headers), { body: responseObject.body }) : combinedHeadersAndBody;\n    }\n}\n/**\n * Take a `FullOperationResponse` and turn it into a flat\n * response object to hand back to the consumer.\n * @param fullResponse - The processed response from the operation request\n * @param responseSpec - The response map from the OperationSpec\n *\n * @internal\n */\nexport function flattenResponse(fullResponse, responseSpec) {\n    var _a, _b;\n    const parsedHeaders = fullResponse.parsedHeaders;\n    // head methods never have a body, but we return a boolean set to body property\n    // to indicate presence/absence of the resource\n    if (fullResponse.request.method === \"HEAD\") {\n        return Object.assign(Object.assign({}, parsedHeaders), { body: fullResponse.parsedBody });\n    }\n    const bodyMapper = responseSpec && responseSpec.bodyMapper;\n    const isNullable = Boolean(bodyMapper === null || bodyMapper === void 0 ? void 0 : bodyMapper.nullable);\n    const expectedBodyTypeName = bodyMapper === null || bodyMapper === void 0 ? void 0 : bodyMapper.type.name;\n    /** If the body is asked for, we look at the expected body type to handle it */\n    if (expectedBodyTypeName === \"Stream\") {\n        return Object.assign(Object.assign({}, parsedHeaders), { blobBody: fullResponse.blobBody, readableStreamBody: fullResponse.readableStreamBody });\n    }\n    const modelProperties = (expectedBodyTypeName === \"Composite\" &&\n        bodyMapper.type.modelProperties) ||\n        {};\n    const isPageableResponse = Object.keys(modelProperties).some((k) => modelProperties[k].serializedName === \"\");\n    if (expectedBodyTypeName === \"Sequence\" || isPageableResponse) {\n        const arrayResponse = (_a = fullResponse.parsedBody) !== null && _a !== void 0 ? _a : [];\n        for (const key of Object.keys(modelProperties)) {\n            if (modelProperties[key].serializedName) {\n                arrayResponse[key] = (_b = fullResponse.parsedBody) === null || _b === void 0 ? void 0 : _b[key];\n            }\n        }\n        if (parsedHeaders) {\n            for (const key of Object.keys(parsedHeaders)) {\n                arrayResponse[key] = parsedHeaders[key];\n            }\n        }\n        return isNullable &&\n            !fullResponse.parsedBody &&\n            !parsedHeaders &&\n            Object.getOwnPropertyNames(modelProperties).length === 0\n            ? null\n            : arrayResponse;\n    }\n    return handleNullableResponseAndWrappableBody({\n        body: fullResponse.parsedBody,\n        headers: parsedHeaders,\n        hasNullableType: isNullable,\n        shouldWrapBody: isPrimitiveBody(fullResponse.parsedBody, expectedBodyTypeName),\n    });\n}\n//# sourceMappingURL=utils.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport * as base64 from \"./base64.js\";\nimport { XML_ATTRKEY, XML_CHARKEY, } from \"./interfaces.js\";\nimport { isDuration, isValidUuid } from \"./utils.js\";\nclass SerializerImpl {\n    constructor(modelMappers = {}, isXML = false) {\n        this.modelMappers = modelMappers;\n        this.isXML = isXML;\n    }\n    /**\n     * @deprecated Removing the constraints validation on client side.\n     */\n    validateConstraints(mapper, value, objectName) {\n        const failValidation = (constraintName, constraintValue) => {\n            throw new Error(`\"${objectName}\" with value \"${value}\" should satisfy the constraint \"${constraintName}\": ${constraintValue}.`);\n        };\n        if (mapper.constraints && value !== undefined && value !== null) {\n            const { ExclusiveMaximum, ExclusiveMinimum, InclusiveMaximum, InclusiveMinimum, MaxItems, MaxLength, MinItems, MinLength, MultipleOf, Pattern, UniqueItems, } = mapper.constraints;\n            if (ExclusiveMaximum !== undefined && value >= ExclusiveMaximum) {\n                failValidation(\"ExclusiveMaximum\", ExclusiveMaximum);\n            }\n            if (ExclusiveMinimum !== undefined && value <= ExclusiveMinimum) {\n                failValidation(\"ExclusiveMinimum\", ExclusiveMinimum);\n            }\n            if (InclusiveMaximum !== undefined && value > InclusiveMaximum) {\n                failValidation(\"InclusiveMaximum\", InclusiveMaximum);\n            }\n            if (InclusiveMinimum !== undefined && value < InclusiveMinimum) {\n                failValidation(\"InclusiveMinimum\", InclusiveMinimum);\n            }\n            if (MaxItems !== undefined && value.length > MaxItems) {\n                failValidation(\"MaxItems\", MaxItems);\n            }\n            if (MaxLength !== undefined && value.length > MaxLength) {\n                failValidation(\"MaxLength\", MaxLength);\n            }\n            if (MinItems !== undefined && value.length < MinItems) {\n                failValidation(\"MinItems\", MinItems);\n            }\n            if (MinLength !== undefined && value.length < MinLength) {\n                failValidation(\"MinLength\", MinLength);\n            }\n            if (MultipleOf !== undefined && value % MultipleOf !== 0) {\n                failValidation(\"MultipleOf\", MultipleOf);\n            }\n            if (Pattern) {\n                const pattern = typeof Pattern === \"string\" ? new RegExp(Pattern) : Pattern;\n                if (typeof value !== \"string\" || value.match(pattern) === null) {\n                    failValidation(\"Pattern\", Pattern);\n                }\n            }\n            if (UniqueItems &&\n                value.some((item, i, ar) => ar.indexOf(item) !== i)) {\n                failValidation(\"UniqueItems\", UniqueItems);\n            }\n        }\n    }\n    /**\n     * Serialize the given object based on its metadata defined in the mapper\n     *\n     * @param mapper - The mapper which defines the metadata of the serializable object\n     *\n     * @param object - A valid Javascript object to be serialized\n     *\n     * @param objectName - Name of the serialized object\n     *\n     * @param options - additional options to serialization\n     *\n     * @returns A valid serialized Javascript object\n     */\n    serialize(mapper, object, objectName, options = { xml: {} }) {\n        var _a, _b, _c;\n        const updatedOptions = {\n            xml: {\n                rootName: (_a = options.xml.rootName) !== null && _a !== void 0 ? _a : \"\",\n                includeRoot: (_b = options.xml.includeRoot) !== null && _b !== void 0 ? _b : false,\n                xmlCharKey: (_c = options.xml.xmlCharKey) !== null && _c !== void 0 ? _c : XML_CHARKEY,\n            },\n        };\n        let payload = {};\n        const mapperType = mapper.type.name;\n        if (!objectName) {\n            objectName = mapper.serializedName;\n        }\n        if (mapperType.match(/^Sequence$/i) !== null) {\n            payload = [];\n        }\n        if (mapper.isConstant) {\n            object = mapper.defaultValue;\n        }\n        // This table of allowed values should help explain\n        // the mapper.required and mapper.nullable properties.\n        // X means \"neither undefined or null are allowed\".\n        //           || required\n        //           || true      | false\n        //  nullable || ==========================\n        //      true || null      | undefined/null\n        //     false || X         | undefined\n        // undefined || X         | undefined/null\n        const { required, nullable } = mapper;\n        if (required && nullable && object === undefined) {\n            throw new Error(`${objectName} cannot be undefined.`);\n        }\n        if (required && !nullable && (object === undefined || object === null)) {\n            throw new Error(`${objectName} cannot be null or undefined.`);\n        }\n        if (!required && nullable === false && object === null) {\n            throw new Error(`${objectName} cannot be null.`);\n        }\n        if (object === undefined || object === null) {\n            payload = object;\n        }\n        else {\n            if (mapperType.match(/^any$/i) !== null) {\n                payload = object;\n            }\n            else if (mapperType.match(/^(Number|String|Boolean|Object|Stream|Uuid)$/i) !== null) {\n                payload = serializeBasicTypes(mapperType, objectName, object);\n            }\n            else if (mapperType.match(/^Enum$/i) !== null) {\n                const enumMapper = mapper;\n                payload = serializeEnumType(objectName, enumMapper.type.allowedValues, object);\n            }\n            else if (mapperType.match(/^(Date|DateTime|TimeSpan|DateTimeRfc1123|UnixTime)$/i) !== null) {\n                payload = serializeDateTypes(mapperType, object, objectName);\n            }\n            else if (mapperType.match(/^ByteArray$/i) !== null) {\n                payload = serializeByteArrayType(objectName, object);\n            }\n            else if (mapperType.match(/^Base64Url$/i) !== null) {\n                payload = serializeBase64UrlType(objectName, object);\n            }\n            else if (mapperType.match(/^Sequence$/i) !== null) {\n                payload = serializeSequenceType(this, mapper, object, objectName, Boolean(this.isXML), updatedOptions);\n            }\n            else if (mapperType.match(/^Dictionary$/i) !== null) {\n                payload = serializeDictionaryType(this, mapper, object, objectName, Boolean(this.isXML), updatedOptions);\n            }\n            else if (mapperType.match(/^Composite$/i) !== null) {\n                payload = serializeCompositeType(this, mapper, object, objectName, Boolean(this.isXML), updatedOptions);\n            }\n        }\n        return payload;\n    }\n    /**\n     * Deserialize the given object based on its metadata defined in the mapper\n     *\n     * @param mapper - The mapper which defines the metadata of the serializable object\n     *\n     * @param responseBody - A valid Javascript entity to be deserialized\n     *\n     * @param objectName - Name of the deserialized object\n     *\n     * @param options - Controls behavior of XML parser and builder.\n     *\n     * @returns A valid deserialized Javascript object\n     */\n    deserialize(mapper, responseBody, objectName, options = { xml: {} }) {\n        var _a, _b, _c, _d;\n        const updatedOptions = {\n            xml: {\n                rootName: (_a = options.xml.rootName) !== null && _a !== void 0 ? _a : \"\",\n                includeRoot: (_b = options.xml.includeRoot) !== null && _b !== void 0 ? _b : false,\n                xmlCharKey: (_c = options.xml.xmlCharKey) !== null && _c !== void 0 ? _c : XML_CHARKEY,\n            },\n            ignoreUnknownProperties: (_d = options.ignoreUnknownProperties) !== null && _d !== void 0 ? _d : false,\n        };\n        if (responseBody === undefined || responseBody === null) {\n            if (this.isXML && mapper.type.name === \"Sequence\" && !mapper.xmlIsWrapped) {\n                // Edge case for empty XML non-wrapped lists. xml2js can't distinguish\n                // between the list being empty versus being missing,\n                // so let's do the more user-friendly thing and return an empty list.\n                responseBody = [];\n            }\n            // specifically check for undefined as default value can be a falsey value `0, \"\", false, null`\n            if (mapper.defaultValue !== undefined) {\n                responseBody = mapper.defaultValue;\n            }\n            return responseBody;\n        }\n        let payload;\n        const mapperType = mapper.type.name;\n        if (!objectName) {\n            objectName = mapper.serializedName;\n        }\n        if (mapperType.match(/^Composite$/i) !== null) {\n            payload = deserializeCompositeType(this, mapper, responseBody, objectName, updatedOptions);\n        }\n        else {\n            if (this.isXML) {\n                const xmlCharKey = updatedOptions.xml.xmlCharKey;\n                /**\n                 * If the mapper specifies this as a non-composite type value but the responseBody contains\n                 * both header (\"$\" i.e., XML_ATTRKEY) and body (\"#\" i.e., XML_CHARKEY) properties,\n                 * then just reduce the responseBody value to the body (\"#\" i.e., XML_CHARKEY) property.\n                 */\n                if (responseBody[XML_ATTRKEY] !== undefined && responseBody[xmlCharKey] !== undefined) {\n                    responseBody = responseBody[xmlCharKey];\n                }\n            }\n            if (mapperType.match(/^Number$/i) !== null) {\n                payload = parseFloat(responseBody);\n                if (isNaN(payload)) {\n                    payload = responseBody;\n                }\n            }\n            else if (mapperType.match(/^Boolean$/i) !== null) {\n                if (responseBody === \"true\") {\n                    payload = true;\n                }\n                else if (responseBody === \"false\") {\n                    payload = false;\n                }\n                else {\n                    payload = responseBody;\n                }\n            }\n            else if (mapperType.match(/^(String|Enum|Object|Stream|Uuid|TimeSpan|any)$/i) !== null) {\n                payload = responseBody;\n            }\n            else if (mapperType.match(/^(Date|DateTime|DateTimeRfc1123)$/i) !== null) {\n                payload = new Date(responseBody);\n            }\n            else if (mapperType.match(/^UnixTime$/i) !== null) {\n                payload = unixTimeToDate(responseBody);\n            }\n            else if (mapperType.match(/^ByteArray$/i) !== null) {\n                payload = base64.decodeString(responseBody);\n            }\n            else if (mapperType.match(/^Base64Url$/i) !== null) {\n                payload = base64UrlToByteArray(responseBody);\n            }\n            else if (mapperType.match(/^Sequence$/i) !== null) {\n                payload = deserializeSequenceType(this, mapper, responseBody, objectName, updatedOptions);\n            }\n            else if (mapperType.match(/^Dictionary$/i) !== null) {\n                payload = deserializeDictionaryType(this, mapper, responseBody, objectName, updatedOptions);\n            }\n        }\n        if (mapper.isConstant) {\n            payload = mapper.defaultValue;\n        }\n        return payload;\n    }\n}\n/**\n * Method that creates and returns a Serializer.\n * @param modelMappers - Known models to map\n * @param isXML - If XML should be supported\n */\nexport function createSerializer(modelMappers = {}, isXML = false) {\n    return new SerializerImpl(modelMappers, isXML);\n}\nfunction trimEnd(str, ch) {\n    let len = str.length;\n    while (len - 1 >= 0 && str[len - 1] === ch) {\n        --len;\n    }\n    return str.substr(0, len);\n}\nfunction bufferToBase64Url(buffer) {\n    if (!buffer) {\n        return undefined;\n    }\n    if (!(buffer instanceof Uint8Array)) {\n        throw new Error(`Please provide an input of type Uint8Array for converting to Base64Url.`);\n    }\n    // Uint8Array to Base64.\n    const str = base64.encodeByteArray(buffer);\n    // Base64 to Base64Url.\n    return trimEnd(str, \"=\").replace(/\\+/g, \"-\").replace(/\\//g, \"_\");\n}\nfunction base64UrlToByteArray(str) {\n    if (!str) {\n        return undefined;\n    }\n    if (str && typeof str.valueOf() !== \"string\") {\n        throw new Error(\"Please provide an input of type string for converting to Uint8Array\");\n    }\n    // Base64Url to Base64.\n    str = str.replace(/-/g, \"+\").replace(/_/g, \"/\");\n    // Base64 to Uint8Array.\n    return base64.decodeString(str);\n}\nfunction splitSerializeName(prop) {\n    const classes = [];\n    let partialclass = \"\";\n    if (prop) {\n        const subwords = prop.split(\".\");\n        for (const item of subwords) {\n            if (item.charAt(item.length - 1) === \"\\\\\") {\n                partialclass += item.substr(0, item.length - 1) + \".\";\n            }\n            else {\n                partialclass += item;\n                classes.push(partialclass);\n                partialclass = \"\";\n            }\n        }\n    }\n    return classes;\n}\nfunction dateToUnixTime(d) {\n    if (!d) {\n        return undefined;\n    }\n    if (typeof d.valueOf() === \"string\") {\n        d = new Date(d);\n    }\n    return Math.floor(d.getTime() / 1000);\n}\nfunction unixTimeToDate(n) {\n    if (!n) {\n        return undefined;\n    }\n    return new Date(n * 1000);\n}\nfunction serializeBasicTypes(typeName, objectName, value) {\n    if (value !== null && value !== undefined) {\n        if (typeName.match(/^Number$/i) !== null) {\n            if (typeof value !== \"number\") {\n                throw new Error(`${objectName} with value ${value} must be of type number.`);\n            }\n        }\n        else if (typeName.match(/^String$/i) !== null) {\n            if (typeof value.valueOf() !== \"string\") {\n                throw new Error(`${objectName} with value \"${value}\" must be of type string.`);\n            }\n        }\n        else if (typeName.match(/^Uuid$/i) !== null) {\n            if (!(typeof value.valueOf() === \"string\" && isValidUuid(value))) {\n                throw new Error(`${objectName} with value \"${value}\" must be of type string and a valid uuid.`);\n            }\n        }\n        else if (typeName.match(/^Boolean$/i) !== null) {\n            if (typeof value !== \"boolean\") {\n                throw new Error(`${objectName} with value ${value} must be of type boolean.`);\n            }\n        }\n        else if (typeName.match(/^Stream$/i) !== null) {\n            const objectType = typeof value;\n            if (objectType !== \"string\" &&\n                typeof value.pipe !== \"function\" && // NodeJS.ReadableStream\n                typeof value.tee !== \"function\" && // browser ReadableStream\n                !(value instanceof ArrayBuffer) &&\n                !ArrayBuffer.isView(value) &&\n                // File objects count as a type of Blob, so we want to use instanceof explicitly\n                !((typeof Blob === \"function\" || typeof Blob === \"object\") && value instanceof Blob) &&\n                objectType !== \"function\") {\n                throw new Error(`${objectName} must be a string, Blob, ArrayBuffer, ArrayBufferView, ReadableStream, or () => ReadableStream.`);\n            }\n        }\n    }\n    return value;\n}\nfunction serializeEnumType(objectName, allowedValues, value) {\n    if (!allowedValues) {\n        throw new Error(`Please provide a set of allowedValues to validate ${objectName} as an Enum Type.`);\n    }\n    const isPresent = allowedValues.some((item) => {\n        if (typeof item.valueOf() === \"string\") {\n            return item.toLowerCase() === value.toLowerCase();\n        }\n        return item === value;\n    });\n    if (!isPresent) {\n        throw new Error(`${value} is not a valid value for ${objectName}. The valid values are: ${JSON.stringify(allowedValues)}.`);\n    }\n    return value;\n}\nfunction serializeByteArrayType(objectName, value) {\n    if (value !== undefined && value !== null) {\n        if (!(value instanceof Uint8Array)) {\n            throw new Error(`${objectName} must be of type Uint8Array.`);\n        }\n        value = base64.encodeByteArray(value);\n    }\n    return value;\n}\nfunction serializeBase64UrlType(objectName, value) {\n    if (value !== undefined && value !== null) {\n        if (!(value instanceof Uint8Array)) {\n            throw new Error(`${objectName} must be of type Uint8Array.`);\n        }\n        value = bufferToBase64Url(value);\n    }\n    return value;\n}\nfunction serializeDateTypes(typeName, value, objectName) {\n    if (value !== undefined && value !== null) {\n        if (typeName.match(/^Date$/i) !== null) {\n            if (!(value instanceof Date ||\n                (typeof value.valueOf() === \"string\" && !isNaN(Date.parse(value))))) {\n                throw new Error(`${objectName} must be an instanceof Date or a string in ISO8601 format.`);\n            }\n            value =\n                value instanceof Date\n                    ? value.toISOString().substring(0, 10)\n                    : new Date(value).toISOString().substring(0, 10);\n        }\n        else if (typeName.match(/^DateTime$/i) !== null) {\n            if (!(value instanceof Date ||\n                (typeof value.valueOf() === \"string\" && !isNaN(Date.parse(value))))) {\n                throw new Error(`${objectName} must be an instanceof Date or a string in ISO8601 format.`);\n            }\n            value = value instanceof Date ? value.toISOString() : new Date(value).toISOString();\n        }\n        else if (typeName.match(/^DateTimeRfc1123$/i) !== null) {\n            if (!(value instanceof Date ||\n                (typeof value.valueOf() === \"string\" && !isNaN(Date.parse(value))))) {\n                throw new Error(`${objectName} must be an instanceof Date or a string in RFC-1123 format.`);\n            }\n            value = value instanceof Date ? value.toUTCString() : new Date(value).toUTCString();\n        }\n        else if (typeName.match(/^UnixTime$/i) !== null) {\n            if (!(value instanceof Date ||\n                (typeof value.valueOf() === \"string\" && !isNaN(Date.parse(value))))) {\n                throw new Error(`${objectName} must be an instanceof Date or a string in RFC-1123/ISO8601 format ` +\n                    `for it to be serialized in UnixTime/Epoch format.`);\n            }\n            value = dateToUnixTime(value);\n        }\n        else if (typeName.match(/^TimeSpan$/i) !== null) {\n            if (!isDuration(value)) {\n                throw new Error(`${objectName} must be a string in ISO 8601 format. Instead was \"${value}\".`);\n            }\n        }\n    }\n    return value;\n}\nfunction serializeSequenceType(serializer, mapper, object, objectName, isXml, options) {\n    var _a;\n    if (!Array.isArray(object)) {\n        throw new Error(`${objectName} must be of type Array.`);\n    }\n    let elementType = mapper.type.element;\n    if (!elementType || typeof elementType !== \"object\") {\n        throw new Error(`element\" metadata for an Array must be defined in the ` +\n            `mapper and it must of type \"object\" in ${objectName}.`);\n    }\n    // Quirk: Composite mappers referenced by `element` might\n    // not have *all* properties declared (like uberParent),\n    // so let's try to look up the full definition by name.\n    if (elementType.type.name === \"Composite\" && elementType.type.className) {\n        elementType = (_a = serializer.modelMappers[elementType.type.className]) !== null && _a !== void 0 ? _a : elementType;\n    }\n    const tempArray = [];\n    for (let i = 0; i < object.length; i++) {\n        const serializedValue = serializer.serialize(elementType, object[i], objectName, options);\n        if (isXml && elementType.xmlNamespace) {\n            const xmlnsKey = elementType.xmlNamespacePrefix\n                ? `xmlns:${elementType.xmlNamespacePrefix}`\n                : \"xmlns\";\n            if (elementType.type.name === \"Composite\") {\n                tempArray[i] = Object.assign({}, serializedValue);\n                tempArray[i][XML_ATTRKEY] = { [xmlnsKey]: elementType.xmlNamespace };\n            }\n            else {\n                tempArray[i] = {};\n                tempArray[i][options.xml.xmlCharKey] = serializedValue;\n                tempArray[i][XML_ATTRKEY] = { [xmlnsKey]: elementType.xmlNamespace };\n            }\n        }\n        else {\n            tempArray[i] = serializedValue;\n        }\n    }\n    return tempArray;\n}\nfunction serializeDictionaryType(serializer, mapper, object, objectName, isXml, options) {\n    if (typeof object !== \"object\") {\n        throw new Error(`${objectName} must be of type object.`);\n    }\n    const valueType = mapper.type.value;\n    if (!valueType || typeof valueType !== \"object\") {\n        throw new Error(`\"value\" metadata for a Dictionary must be defined in the ` +\n            `mapper and it must of type \"object\" in ${objectName}.`);\n    }\n    const tempDictionary = {};\n    for (const key of Object.keys(object)) {\n        const serializedValue = serializer.serialize(valueType, object[key], objectName, options);\n        // If the element needs an XML namespace we need to add it within the $ property\n        tempDictionary[key] = getXmlObjectValue(valueType, serializedValue, isXml, options);\n    }\n    // Add the namespace to the root element if needed\n    if (isXml && mapper.xmlNamespace) {\n        const xmlnsKey = mapper.xmlNamespacePrefix ? `xmlns:${mapper.xmlNamespacePrefix}` : \"xmlns\";\n        const result = tempDictionary;\n        result[XML_ATTRKEY] = { [xmlnsKey]: mapper.xmlNamespace };\n        return result;\n    }\n    return tempDictionary;\n}\n/**\n * Resolves the additionalProperties property from a referenced mapper\n * @param serializer - the serializer containing the entire set of mappers\n * @param mapper - the composite mapper to resolve\n * @param objectName - name of the object being serialized\n */\nfunction resolveAdditionalProperties(serializer, mapper, objectName) {\n    const additionalProperties = mapper.type.additionalProperties;\n    if (!additionalProperties && mapper.type.className) {\n        const modelMapper = resolveReferencedMapper(serializer, mapper, objectName);\n        return modelMapper === null || modelMapper === void 0 ? void 0 : modelMapper.type.additionalProperties;\n    }\n    return additionalProperties;\n}\n/**\n * Finds the mapper referenced by className\n * @param serializer - the serializer containing the entire set of mappers\n * @param mapper - the composite mapper to resolve\n * @param objectName - name of the object being serialized\n */\nfunction resolveReferencedMapper(serializer, mapper, objectName) {\n    const className = mapper.type.className;\n    if (!className) {\n        throw new Error(`Class name for model \"${objectName}\" is not provided in the mapper \"${JSON.stringify(mapper, undefined, 2)}\".`);\n    }\n    return serializer.modelMappers[className];\n}\n/**\n * Resolves a composite mapper's modelProperties.\n * @param serializer - the serializer containing the entire set of mappers\n * @param mapper - the composite mapper to resolve\n */\nfunction resolveModelProperties(serializer, mapper, objectName) {\n    let modelProps = mapper.type.modelProperties;\n    if (!modelProps) {\n        const modelMapper = resolveReferencedMapper(serializer, mapper, objectName);\n        if (!modelMapper) {\n            throw new Error(`mapper() cannot be null or undefined for model \"${mapper.type.className}\".`);\n        }\n        modelProps = modelMapper === null || modelMapper === void 0 ? void 0 : modelMapper.type.modelProperties;\n        if (!modelProps) {\n            throw new Error(`modelProperties cannot be null or undefined in the ` +\n                `mapper \"${JSON.stringify(modelMapper)}\" of type \"${mapper.type.className}\" for object \"${objectName}\".`);\n        }\n    }\n    return modelProps;\n}\nfunction serializeCompositeType(serializer, mapper, object, objectName, isXml, options) {\n    if (getPolymorphicDiscriminatorRecursively(serializer, mapper)) {\n        mapper = getPolymorphicMapper(serializer, mapper, object, \"clientName\");\n    }\n    if (object !== undefined && object !== null) {\n        const payload = {};\n        const modelProps = resolveModelProperties(serializer, mapper, objectName);\n        for (const key of Object.keys(modelProps)) {\n            const propertyMapper = modelProps[key];\n            if (propertyMapper.readOnly) {\n                continue;\n            }\n            let propName;\n            let parentObject = payload;\n            if (serializer.isXML) {\n                if (propertyMapper.xmlIsWrapped) {\n                    propName = propertyMapper.xmlName;\n                }\n                else {\n                    propName = propertyMapper.xmlElementName || propertyMapper.xmlName;\n                }\n            }\n            else {\n                const paths = splitSerializeName(propertyMapper.serializedName);\n                propName = paths.pop();\n                for (const pathName of paths) {\n                    const childObject = parentObject[pathName];\n                    if ((childObject === undefined || childObject === null) &&\n                        ((object[key] !== undefined && object[key] !== null) ||\n                            propertyMapper.defaultValue !== undefined)) {\n                        parentObject[pathName] = {};\n                    }\n                    parentObject = parentObject[pathName];\n                }\n            }\n            if (parentObject !== undefined && parentObject !== null) {\n                if (isXml && mapper.xmlNamespace) {\n                    const xmlnsKey = mapper.xmlNamespacePrefix\n                        ? `xmlns:${mapper.xmlNamespacePrefix}`\n                        : \"xmlns\";\n                    parentObject[XML_ATTRKEY] = Object.assign(Object.assign({}, parentObject[XML_ATTRKEY]), { [xmlnsKey]: mapper.xmlNamespace });\n                }\n                const propertyObjectName = propertyMapper.serializedName !== \"\"\n                    ? objectName + \".\" + propertyMapper.serializedName\n                    : objectName;\n                let toSerialize = object[key];\n                const polymorphicDiscriminator = getPolymorphicDiscriminatorRecursively(serializer, mapper);\n                if (polymorphicDiscriminator &&\n                    polymorphicDiscriminator.clientName === key &&\n                    (toSerialize === undefined || toSerialize === null)) {\n                    toSerialize = mapper.serializedName;\n                }\n                const serializedValue = serializer.serialize(propertyMapper, toSerialize, propertyObjectName, options);\n                if (serializedValue !== undefined && propName !== undefined && propName !== null) {\n                    const value = getXmlObjectValue(propertyMapper, serializedValue, isXml, options);\n                    if (isXml && propertyMapper.xmlIsAttribute) {\n                        // XML_ATTRKEY, i.e., $ is the key attributes are kept under in xml2js.\n                        // This keeps things simple while preventing name collision\n                        // with names in user documents.\n                        parentObject[XML_ATTRKEY] = parentObject[XML_ATTRKEY] || {};\n                        parentObject[XML_ATTRKEY][propName] = serializedValue;\n                    }\n                    else if (isXml && propertyMapper.xmlIsWrapped) {\n                        parentObject[propName] = { [propertyMapper.xmlElementName]: value };\n                    }\n                    else {\n                        parentObject[propName] = value;\n                    }\n                }\n            }\n        }\n        const additionalPropertiesMapper = resolveAdditionalProperties(serializer, mapper, objectName);\n        if (additionalPropertiesMapper) {\n            const propNames = Object.keys(modelProps);\n            for (const clientPropName in object) {\n                const isAdditionalProperty = propNames.every((pn) => pn !== clientPropName);\n                if (isAdditionalProperty) {\n                    payload[clientPropName] = serializer.serialize(additionalPropertiesMapper, object[clientPropName], objectName + '[\"' + clientPropName + '\"]', options);\n                }\n            }\n        }\n        return payload;\n    }\n    return object;\n}\nfunction getXmlObjectValue(propertyMapper, serializedValue, isXml, options) {\n    if (!isXml || !propertyMapper.xmlNamespace) {\n        return serializedValue;\n    }\n    const xmlnsKey = propertyMapper.xmlNamespacePrefix\n        ? `xmlns:${propertyMapper.xmlNamespacePrefix}`\n        : \"xmlns\";\n    const xmlNamespace = { [xmlnsKey]: propertyMapper.xmlNamespace };\n    if ([\"Composite\"].includes(propertyMapper.type.name)) {\n        if (serializedValue[XML_ATTRKEY]) {\n            return serializedValue;\n        }\n        else {\n            const result = Object.assign({}, serializedValue);\n            result[XML_ATTRKEY] = xmlNamespace;\n            return result;\n        }\n    }\n    const result = {};\n    result[options.xml.xmlCharKey] = serializedValue;\n    result[XML_ATTRKEY] = xmlNamespace;\n    return result;\n}\nfunction isSpecialXmlProperty(propertyName, options) {\n    return [XML_ATTRKEY, options.xml.xmlCharKey].includes(propertyName);\n}\nfunction deserializeCompositeType(serializer, mapper, responseBody, objectName, options) {\n    var _a, _b;\n    const xmlCharKey = (_a = options.xml.xmlCharKey) !== null && _a !== void 0 ? _a : XML_CHARKEY;\n    if (getPolymorphicDiscriminatorRecursively(serializer, mapper)) {\n        mapper = getPolymorphicMapper(serializer, mapper, responseBody, \"serializedName\");\n    }\n    const modelProps = resolveModelProperties(serializer, mapper, objectName);\n    let instance = {};\n    const handledPropertyNames = [];\n    for (const key of Object.keys(modelProps)) {\n        const propertyMapper = modelProps[key];\n        const paths = splitSerializeName(modelProps[key].serializedName);\n        handledPropertyNames.push(paths[0]);\n        const { serializedName, xmlName, xmlElementName } = propertyMapper;\n        let propertyObjectName = objectName;\n        if (serializedName !== \"\" && serializedName !== undefined) {\n            propertyObjectName = objectName + \".\" + serializedName;\n        }\n        const headerCollectionPrefix = propertyMapper.headerCollectionPrefix;\n        if (headerCollectionPrefix) {\n            const dictionary = {};\n            for (const headerKey of Object.keys(responseBody)) {\n                if (headerKey.startsWith(headerCollectionPrefix)) {\n                    dictionary[headerKey.substring(headerCollectionPrefix.length)] = serializer.deserialize(propertyMapper.type.value, responseBody[headerKey], propertyObjectName, options);\n                }\n                handledPropertyNames.push(headerKey);\n            }\n            instance[key] = dictionary;\n        }\n        else if (serializer.isXML) {\n            if (propertyMapper.xmlIsAttribute && responseBody[XML_ATTRKEY]) {\n                instance[key] = serializer.deserialize(propertyMapper, responseBody[XML_ATTRKEY][xmlName], propertyObjectName, options);\n            }\n            else if (propertyMapper.xmlIsMsText) {\n                if (responseBody[xmlCharKey] !== undefined) {\n                    instance[key] = responseBody[xmlCharKey];\n                }\n                else if (typeof responseBody === \"string\") {\n                    // The special case where xml parser parses \"<Name>content</Name>\" into JSON of\n                    //   `{ name: \"content\"}` instead of `{ name: { \"_\": \"content\" }}`\n                    instance[key] = responseBody;\n                }\n            }\n            else {\n                const propertyName = xmlElementName || xmlName || serializedName;\n                if (propertyMapper.xmlIsWrapped) {\n                    /* a list of <xmlElementName> wrapped by <xmlName>\n                      For the xml example below\n                        <Cors>\n                          <CorsRule>...</CorsRule>\n                          <CorsRule>...</CorsRule>\n                        </Cors>\n                      the responseBody has\n                        {\n                          Cors: {\n                            CorsRule: [{...}, {...}]\n                          }\n                        }\n                      xmlName is \"Cors\" and xmlElementName is\"CorsRule\".\n                    */\n                    const wrapped = responseBody[xmlName];\n                    const elementList = (_b = wrapped === null || wrapped === void 0 ? void 0 : wrapped[xmlElementName]) !== null && _b !== void 0 ? _b : [];\n                    instance[key] = serializer.deserialize(propertyMapper, elementList, propertyObjectName, options);\n                    handledPropertyNames.push(xmlName);\n                }\n                else {\n                    const property = responseBody[propertyName];\n                    instance[key] = serializer.deserialize(propertyMapper, property, propertyObjectName, options);\n                    handledPropertyNames.push(propertyName);\n                }\n            }\n        }\n        else {\n            // deserialize the property if it is present in the provided responseBody instance\n            let propertyInstance;\n            let res = responseBody;\n            // traversing the object step by step.\n            let steps = 0;\n            for (const item of paths) {\n                if (!res)\n                    break;\n                steps++;\n                res = res[item];\n            }\n            // only accept null when reaching the last position of object otherwise it would be undefined\n            if (res === null && steps < paths.length) {\n                res = undefined;\n            }\n            propertyInstance = res;\n            const polymorphicDiscriminator = mapper.type.polymorphicDiscriminator;\n            // checking that the model property name (key)(ex: \"fishtype\") and the\n            // clientName of the polymorphicDiscriminator {metadata} (ex: \"fishtype\")\n            // instead of the serializedName of the polymorphicDiscriminator (ex: \"fish.type\")\n            // is a better approach. The generator is not consistent with escaping '\\.' in the\n            // serializedName of the property (ex: \"fish\\.type\") that is marked as polymorphic discriminator\n            // and the serializedName of the metadata polymorphicDiscriminator (ex: \"fish.type\"). However,\n            // the clientName transformation of the polymorphicDiscriminator (ex: \"fishtype\") and\n            // the transformation of model property name (ex: \"fishtype\") is done consistently.\n            // Hence, it is a safer bet to rely on the clientName of the polymorphicDiscriminator.\n            if (polymorphicDiscriminator &&\n                key === polymorphicDiscriminator.clientName &&\n                (propertyInstance === undefined || propertyInstance === null)) {\n                propertyInstance = mapper.serializedName;\n            }\n            let serializedValue;\n            // paging\n            if (Array.isArray(responseBody[key]) && modelProps[key].serializedName === \"\") {\n                propertyInstance = responseBody[key];\n                const arrayInstance = serializer.deserialize(propertyMapper, propertyInstance, propertyObjectName, options);\n                // Copy over any properties that have already been added into the instance, where they do\n                // not exist on the newly de-serialized array\n                for (const [k, v] of Object.entries(instance)) {\n                    if (!Object.prototype.hasOwnProperty.call(arrayInstance, k)) {\n                        arrayInstance[k] = v;\n                    }\n                }\n                instance = arrayInstance;\n            }\n            else if (propertyInstance !== undefined || propertyMapper.defaultValue !== undefined) {\n                serializedValue = serializer.deserialize(propertyMapper, propertyInstance, propertyObjectName, options);\n                instance[key] = serializedValue;\n            }\n        }\n    }\n    const additionalPropertiesMapper = mapper.type.additionalProperties;\n    if (additionalPropertiesMapper) {\n        const isAdditionalProperty = (responsePropName) => {\n            for (const clientPropName in modelProps) {\n                const paths = splitSerializeName(modelProps[clientPropName].serializedName);\n                if (paths[0] === responsePropName) {\n                    return false;\n                }\n            }\n            return true;\n        };\n        for (const responsePropName in responseBody) {\n            if (isAdditionalProperty(responsePropName)) {\n                instance[responsePropName] = serializer.deserialize(additionalPropertiesMapper, responseBody[responsePropName], objectName + '[\"' + responsePropName + '\"]', options);\n            }\n        }\n    }\n    else if (responseBody && !options.ignoreUnknownProperties) {\n        for (const key of Object.keys(responseBody)) {\n            if (instance[key] === undefined &&\n                !handledPropertyNames.includes(key) &&\n                !isSpecialXmlProperty(key, options)) {\n                instance[key] = responseBody[key];\n            }\n        }\n    }\n    return instance;\n}\nfunction deserializeDictionaryType(serializer, mapper, responseBody, objectName, options) {\n    /* jshint validthis: true */\n    const value = mapper.type.value;\n    if (!value || typeof value !== \"object\") {\n        throw new Error(`\"value\" metadata for a Dictionary must be defined in the ` +\n            `mapper and it must of type \"object\" in ${objectName}`);\n    }\n    if (responseBody) {\n        const tempDictionary = {};\n        for (const key of Object.keys(responseBody)) {\n            tempDictionary[key] = serializer.deserialize(value, responseBody[key], objectName, options);\n        }\n        return tempDictionary;\n    }\n    return responseBody;\n}\nfunction deserializeSequenceType(serializer, mapper, responseBody, objectName, options) {\n    var _a;\n    let element = mapper.type.element;\n    if (!element || typeof element !== \"object\") {\n        throw new Error(`element\" metadata for an Array must be defined in the ` +\n            `mapper and it must of type \"object\" in ${objectName}`);\n    }\n    if (responseBody) {\n        if (!Array.isArray(responseBody)) {\n            // xml2js will interpret a single element array as just the element, so force it to be an array\n            responseBody = [responseBody];\n        }\n        // Quirk: Composite mappers referenced by `element` might\n        // not have *all* properties declared (like uberParent),\n        // so let's try to look up the full definition by name.\n        if (element.type.name === \"Composite\" && element.type.className) {\n            element = (_a = serializer.modelMappers[element.type.className]) !== null && _a !== void 0 ? _a : element;\n        }\n        const tempArray = [];\n        for (let i = 0; i < responseBody.length; i++) {\n            tempArray[i] = serializer.deserialize(element, responseBody[i], `${objectName}[${i}]`, options);\n        }\n        return tempArray;\n    }\n    return responseBody;\n}\nfunction getIndexDiscriminator(discriminators, discriminatorValue, typeName) {\n    const typeNamesToCheck = [typeName];\n    while (typeNamesToCheck.length) {\n        const currentName = typeNamesToCheck.shift();\n        const indexDiscriminator = discriminatorValue === currentName\n            ? discriminatorValue\n            : currentName + \".\" + discriminatorValue;\n        if (Object.prototype.hasOwnProperty.call(discriminators, indexDiscriminator)) {\n            return discriminators[indexDiscriminator];\n        }\n        else {\n            for (const [name, mapper] of Object.entries(discriminators)) {\n                if (name.startsWith(currentName + \".\") &&\n                    mapper.type.uberParent === currentName &&\n                    mapper.type.className) {\n                    typeNamesToCheck.push(mapper.type.className);\n                }\n            }\n        }\n    }\n    return undefined;\n}\nfunction getPolymorphicMapper(serializer, mapper, object, polymorphicPropertyName) {\n    var _a;\n    const polymorphicDiscriminator = getPolymorphicDiscriminatorRecursively(serializer, mapper);\n    if (polymorphicDiscriminator) {\n        let discriminatorName = polymorphicDiscriminator[polymorphicPropertyName];\n        if (discriminatorName) {\n            // The serializedName might have \\\\, which we just want to ignore\n            if (polymorphicPropertyName === \"serializedName\") {\n                discriminatorName = discriminatorName.replace(/\\\\/gi, \"\");\n            }\n            const discriminatorValue = object[discriminatorName];\n            const typeName = (_a = mapper.type.uberParent) !== null && _a !== void 0 ? _a : mapper.type.className;\n            if (typeof discriminatorValue === \"string\" && typeName) {\n                const polymorphicMapper = getIndexDiscriminator(serializer.modelMappers.discriminators, discriminatorValue, typeName);\n                if (polymorphicMapper) {\n                    mapper = polymorphicMapper;\n                }\n            }\n        }\n    }\n    return mapper;\n}\nfunction getPolymorphicDiscriminatorRecursively(serializer, mapper) {\n    return (mapper.type.polymorphicDiscriminator ||\n        getPolymorphicDiscriminatorSafely(serializer, mapper.type.uberParent) ||\n        getPolymorphicDiscriminatorSafely(serializer, mapper.type.className));\n}\nfunction getPolymorphicDiscriminatorSafely(serializer, typeName) {\n    return (typeName &&\n        serializer.modelMappers[typeName] &&\n        serializer.modelMappers[typeName].type.polymorphicDiscriminator);\n}\n/**\n * Known types of Mappers\n */\nexport const MapperTypeNames = {\n    Base64Url: \"Base64Url\",\n    Boolean: \"Boolean\",\n    ByteArray: \"ByteArray\",\n    Composite: \"Composite\",\n    Date: \"Date\",\n    DateTime: \"DateTime\",\n    DateTimeRfc1123: \"DateTimeRfc1123\",\n    Dictionary: \"Dictionary\",\n    Enum: \"Enum\",\n    Number: \"Number\",\n    Object: \"Object\",\n    Sequence: \"Sequence\",\n    String: \"String\",\n    Stream: \"Stream\",\n    TimeSpan: \"TimeSpan\",\n    UnixTime: \"UnixTime\",\n};\n//# sourceMappingURL=serializer.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\n/**\n * Browser-only implementation of the module's state. The browser esm variant will not load the commonjs state, so we do not need to share state between the two.\n */\nexport const state = {\n    operationRequestMap: new WeakMap(),\n};\n//# sourceMappingURL=state-browser.mjs.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { state } from \"./state.js\";\n/**\n * @internal\n * Retrieves the value to use for a given operation argument\n * @param operationArguments - The arguments passed from the generated client\n * @param parameter - The parameter description\n * @param fallbackObject - If something isn't found in the arguments bag, look here.\n *  Generally used to look at the service client properties.\n */\nexport function getOperationArgumentValueFromParameter(operationArguments, parameter, fallbackObject) {\n    let parameterPath = parameter.parameterPath;\n    const parameterMapper = parameter.mapper;\n    let value;\n    if (typeof parameterPath === \"string\") {\n        parameterPath = [parameterPath];\n    }\n    if (Array.isArray(parameterPath)) {\n        if (parameterPath.length > 0) {\n            if (parameterMapper.isConstant) {\n                value = parameterMapper.defaultValue;\n            }\n            else {\n                let propertySearchResult = getPropertyFromParameterPath(operationArguments, parameterPath);\n                if (!propertySearchResult.propertyFound && fallbackObject) {\n                    propertySearchResult = getPropertyFromParameterPath(fallbackObject, parameterPath);\n                }\n                let useDefaultValue = false;\n                if (!propertySearchResult.propertyFound) {\n                    useDefaultValue =\n                        parameterMapper.required ||\n                            (parameterPath[0] === \"options\" && parameterPath.length === 2);\n                }\n                value = useDefaultValue ? parameterMapper.defaultValue : propertySearchResult.propertyValue;\n            }\n        }\n    }\n    else {\n        if (parameterMapper.required) {\n            value = {};\n        }\n        for (const propertyName in parameterPath) {\n            const propertyMapper = parameterMapper.type.modelProperties[propertyName];\n            const propertyPath = parameterPath[propertyName];\n            const propertyValue = getOperationArgumentValueFromParameter(operationArguments, {\n                parameterPath: propertyPath,\n                mapper: propertyMapper,\n            }, fallbackObject);\n            if (propertyValue !== undefined) {\n                if (!value) {\n                    value = {};\n                }\n                value[propertyName] = propertyValue;\n            }\n        }\n    }\n    return value;\n}\nfunction getPropertyFromParameterPath(parent, parameterPath) {\n    const result = { propertyFound: false };\n    let i = 0;\n    for (; i < parameterPath.length; ++i) {\n        const parameterPathPart = parameterPath[i];\n        // Make sure to check inherited properties too, so don't use hasOwnProperty().\n        if (parent && parameterPathPart in parent) {\n            parent = parent[parameterPathPart];\n        }\n        else {\n            break;\n        }\n    }\n    if (i === parameterPath.length) {\n        result.propertyValue = parent;\n        result.propertyFound = true;\n    }\n    return result;\n}\nconst originalRequestSymbol = Symbol.for(\"@azure/core-client original request\");\nfunction hasOriginalRequest(request) {\n    return originalRequestSymbol in request;\n}\nexport function getOperationRequestInfo(request) {\n    if (hasOriginalRequest(request)) {\n        return getOperationRequestInfo(request[originalRequestSymbol]);\n    }\n    let info = state.operationRequestMap.get(request);\n    if (!info) {\n        info = {};\n        state.operationRequestMap.set(request, info);\n    }\n    return info;\n}\n//# sourceMappingURL=operationHelpers.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { XML_CHARKEY, } from \"./interfaces.js\";\nimport { RestError, } from \"@azure/core-rest-pipeline\";\nimport { MapperTypeNames } from \"./serializer.js\";\nimport { getOperationRequestInfo } from \"./operationHelpers.js\";\nconst defaultJsonContentTypes = [\"application/json\", \"text/json\"];\nconst defaultXmlContentTypes = [\"application/xml\", \"application/atom+xml\"];\n/**\n * The programmatic identifier of the deserializationPolicy.\n */\nexport const deserializationPolicyName = \"deserializationPolicy\";\n/**\n * This policy handles parsing out responses according to OperationSpecs on the request.\n */\nexport function deserializationPolicy(options = {}) {\n    var _a, _b, _c, _d, _e, _f, _g;\n    const jsonContentTypes = (_b = (_a = options.expectedContentTypes) === null || _a === void 0 ? void 0 : _a.json) !== null && _b !== void 0 ? _b : defaultJsonContentTypes;\n    const xmlContentTypes = (_d = (_c = options.expectedContentTypes) === null || _c === void 0 ? void 0 : _c.xml) !== null && _d !== void 0 ? _d : defaultXmlContentTypes;\n    const parseXML = options.parseXML;\n    const serializerOptions = options.serializerOptions;\n    const updatedOptions = {\n        xml: {\n            rootName: (_e = serializerOptions === null || serializerOptions === void 0 ? void 0 : serializerOptions.xml.rootName) !== null && _e !== void 0 ? _e : \"\",\n            includeRoot: (_f = serializerOptions === null || serializerOptions === void 0 ? void 0 : serializerOptions.xml.includeRoot) !== null && _f !== void 0 ? _f : false,\n            xmlCharKey: (_g = serializerOptions === null || serializerOptions === void 0 ? void 0 : serializerOptions.xml.xmlCharKey) !== null && _g !== void 0 ? _g : XML_CHARKEY,\n        },\n    };\n    return {\n        name: deserializationPolicyName,\n        async sendRequest(request, next) {\n            const response = await next(request);\n            return deserializeResponseBody(jsonContentTypes, xmlContentTypes, response, updatedOptions, parseXML);\n        },\n    };\n}\nfunction getOperationResponseMap(parsedResponse) {\n    let result;\n    const request = parsedResponse.request;\n    const operationInfo = getOperationRequestInfo(request);\n    const operationSpec = operationInfo === null || operationInfo === void 0 ? void 0 : operationInfo.operationSpec;\n    if (operationSpec) {\n        if (!(operationInfo === null || operationInfo === void 0 ? void 0 : operationInfo.operationResponseGetter)) {\n            result = operationSpec.responses[parsedResponse.status];\n        }\n        else {\n            result = operationInfo === null || operationInfo === void 0 ? void 0 : operationInfo.operationResponseGetter(operationSpec, parsedResponse);\n        }\n    }\n    return result;\n}\nfunction shouldDeserializeResponse(parsedResponse) {\n    const request = parsedResponse.request;\n    const operationInfo = getOperationRequestInfo(request);\n    const shouldDeserialize = operationInfo === null || operationInfo === void 0 ? void 0 : operationInfo.shouldDeserialize;\n    let result;\n    if (shouldDeserialize === undefined) {\n        result = true;\n    }\n    else if (typeof shouldDeserialize === \"boolean\") {\n        result = shouldDeserialize;\n    }\n    else {\n        result = shouldDeserialize(parsedResponse);\n    }\n    return result;\n}\nasync function deserializeResponseBody(jsonContentTypes, xmlContentTypes, response, options, parseXML) {\n    const parsedResponse = await parse(jsonContentTypes, xmlContentTypes, response, options, parseXML);\n    if (!shouldDeserializeResponse(parsedResponse)) {\n        return parsedResponse;\n    }\n    const operationInfo = getOperationRequestInfo(parsedResponse.request);\n    const operationSpec = operationInfo === null || operationInfo === void 0 ? void 0 : operationInfo.operationSpec;\n    if (!operationSpec || !operationSpec.responses) {\n        return parsedResponse;\n    }\n    const responseSpec = getOperationResponseMap(parsedResponse);\n    const { error, shouldReturnResponse } = handleErrorResponse(parsedResponse, operationSpec, responseSpec, options);\n    if (error) {\n        throw error;\n    }\n    else if (shouldReturnResponse) {\n        return parsedResponse;\n    }\n    // An operation response spec does exist for current status code, so\n    // use it to deserialize the response.\n    if (responseSpec) {\n        if (responseSpec.bodyMapper) {\n            let valueToDeserialize = parsedResponse.parsedBody;\n            if (operationSpec.isXML && responseSpec.bodyMapper.type.name === MapperTypeNames.Sequence) {\n                valueToDeserialize =\n                    typeof valueToDeserialize === \"object\"\n                        ? valueToDeserialize[responseSpec.bodyMapper.xmlElementName]\n                        : [];\n            }\n            try {\n                parsedResponse.parsedBody = operationSpec.serializer.deserialize(responseSpec.bodyMapper, valueToDeserialize, \"operationRes.parsedBody\", options);\n            }\n            catch (deserializeError) {\n                const restError = new RestError(`Error ${deserializeError} occurred in deserializing the responseBody - ${parsedResponse.bodyAsText}`, {\n                    statusCode: parsedResponse.status,\n                    request: parsedResponse.request,\n                    response: parsedResponse,\n                });\n                throw restError;\n            }\n        }\n        else if (operationSpec.httpMethod === \"HEAD\") {\n            // head methods never have a body, but we return a boolean to indicate presence/absence of the resource\n            parsedResponse.parsedBody = response.status >= 200 && response.status < 300;\n        }\n        if (responseSpec.headersMapper) {\n            parsedResponse.parsedHeaders = operationSpec.serializer.deserialize(responseSpec.headersMapper, parsedResponse.headers.toJSON(), \"operationRes.parsedHeaders\", { xml: {}, ignoreUnknownProperties: true });\n        }\n    }\n    return parsedResponse;\n}\nfunction isOperationSpecEmpty(operationSpec) {\n    const expectedStatusCodes = Object.keys(operationSpec.responses);\n    return (expectedStatusCodes.length === 0 ||\n        (expectedStatusCodes.length === 1 && expectedStatusCodes[0] === \"default\"));\n}\nfunction handleErrorResponse(parsedResponse, operationSpec, responseSpec, options) {\n    var _a;\n    const isSuccessByStatus = 200 <= parsedResponse.status && parsedResponse.status < 300;\n    const isExpectedStatusCode = isOperationSpecEmpty(operationSpec)\n        ? isSuccessByStatus\n        : !!responseSpec;\n    if (isExpectedStatusCode) {\n        if (responseSpec) {\n            if (!responseSpec.isError) {\n                return { error: null, shouldReturnResponse: false };\n            }\n        }\n        else {\n            return { error: null, shouldReturnResponse: false };\n        }\n    }\n    const errorResponseSpec = responseSpec !== null && responseSpec !== void 0 ? responseSpec : operationSpec.responses.default;\n    const initialErrorMessage = ((_a = parsedResponse.request.streamResponseStatusCodes) === null || _a === void 0 ? void 0 : _a.has(parsedResponse.status))\n        ? `Unexpected status code: ${parsedResponse.status}`\n        : parsedResponse.bodyAsText;\n    const error = new RestError(initialErrorMessage, {\n        statusCode: parsedResponse.status,\n        request: parsedResponse.request,\n        response: parsedResponse,\n    });\n    // If the item failed but there's no error spec or default spec to deserialize the error,\n    // we should fail so we just throw the parsed response\n    if (!errorResponseSpec) {\n        throw error;\n    }\n    const defaultBodyMapper = errorResponseSpec.bodyMapper;\n    const defaultHeadersMapper = errorResponseSpec.headersMapper;\n    try {\n        // If error response has a body, try to deserialize it using default body mapper.\n        // Then try to extract error code & message from it\n        if (parsedResponse.parsedBody) {\n            const parsedBody = parsedResponse.parsedBody;\n            let deserializedError;\n            if (defaultBodyMapper) {\n                let valueToDeserialize = parsedBody;\n                if (operationSpec.isXML && defaultBodyMapper.type.name === MapperTypeNames.Sequence) {\n                    valueToDeserialize = [];\n                    const elementName = defaultBodyMapper.xmlElementName;\n                    if (typeof parsedBody === \"object\" && elementName) {\n                        valueToDeserialize = parsedBody[elementName];\n                    }\n                }\n                deserializedError = operationSpec.serializer.deserialize(defaultBodyMapper, valueToDeserialize, \"error.response.parsedBody\", options);\n            }\n            const internalError = parsedBody.error || deserializedError || parsedBody;\n            error.code = internalError.code;\n            if (internalError.message) {\n                error.message = internalError.message;\n            }\n            if (defaultBodyMapper) {\n                error.response.parsedBody = deserializedError;\n            }\n        }\n        // If error response has headers, try to deserialize it using default header mapper\n        if (parsedResponse.headers && defaultHeadersMapper) {\n            error.response.parsedHeaders =\n                operationSpec.serializer.deserialize(defaultHeadersMapper, parsedResponse.headers.toJSON(), \"operationRes.parsedHeaders\");\n        }\n    }\n    catch (defaultError) {\n        error.message = `Error \"${defaultError.message}\" occurred in deserializing the responseBody - \"${parsedResponse.bodyAsText}\" for the default response.`;\n    }\n    return { error, shouldReturnResponse: false };\n}\nasync function parse(jsonContentTypes, xmlContentTypes, operationResponse, opts, parseXML) {\n    var _a;\n    if (!((_a = operationResponse.request.streamResponseStatusCodes) === null || _a === void 0 ? void 0 : _a.has(operationResponse.status)) &&\n        operationResponse.bodyAsText) {\n        const text = operationResponse.bodyAsText;\n        const contentType = operationResponse.headers.get(\"Content-Type\") || \"\";\n        const contentComponents = !contentType\n            ? []\n            : contentType.split(\";\").map((component) => component.toLowerCase());\n        try {\n            if (contentComponents.length === 0 ||\n                contentComponents.some((component) => jsonContentTypes.indexOf(component) !== -1)) {\n                operationResponse.parsedBody = JSON.parse(text);\n                return operationResponse;\n            }\n            else if (contentComponents.some((component) => xmlContentTypes.indexOf(component) !== -1)) {\n                if (!parseXML) {\n                    throw new Error(\"Parsing XML not supported.\");\n                }\n                const body = await parseXML(text, opts.xml);\n                operationResponse.parsedBody = body;\n                return operationResponse;\n            }\n        }\n        catch (err) {\n            const msg = `Error \"${err}\" occurred while parsing the response body - ${operationResponse.bodyAsText}.`;\n            const errCode = err.code || RestError.PARSE_ERROR;\n            const e = new RestError(msg, {\n                code: errCode,\n                statusCode: operationResponse.status,\n                request: operationResponse.request,\n                response: operationResponse,\n            });\n            throw e;\n        }\n    }\n    return operationResponse;\n}\n//# sourceMappingURL=deserializationPolicy.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { MapperTypeNames } from \"./serializer.js\";\n/**\n * Gets the list of status codes for streaming responses.\n * @internal\n */\nexport function getStreamingResponseStatusCodes(operationSpec) {\n    const result = new Set();\n    for (const statusCode in operationSpec.responses) {\n        const operationResponse = operationSpec.responses[statusCode];\n        if (operationResponse.bodyMapper &&\n            operationResponse.bodyMapper.type.name === MapperTypeNames.Stream) {\n            result.add(Number(statusCode));\n        }\n    }\n    return result;\n}\n/**\n * Get the path to this parameter's value as a dotted string (a.b.c).\n * @param parameter - The parameter to get the path string for.\n * @returns The path to this parameter's value as a dotted string.\n * @internal\n */\nexport function getPathStringFromParameter(parameter) {\n    const { parameterPath, mapper } = parameter;\n    let result;\n    if (typeof parameterPath === \"string\") {\n        result = parameterPath;\n    }\n    else if (Array.isArray(parameterPath)) {\n        result = parameterPath.join(\".\");\n    }\n    else {\n        result = mapper.serializedName;\n    }\n    return result;\n}\n//# sourceMappingURL=interfaceHelpers.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { XML_ATTRKEY, XML_CHARKEY, } from \"./interfaces.js\";\nimport { getOperationArgumentValueFromParameter, getOperationRequestInfo, } from \"./operationHelpers.js\";\nimport { MapperTypeNames } from \"./serializer.js\";\nimport { getPathStringFromParameter } from \"./interfaceHelpers.js\";\n/**\n * The programmatic identifier of the serializationPolicy.\n */\nexport const serializationPolicyName = \"serializationPolicy\";\n/**\n * This policy handles assembling the request body and headers using\n * an OperationSpec and OperationArguments on the request.\n */\nexport function serializationPolicy(options = {}) {\n    const stringifyXML = options.stringifyXML;\n    return {\n        name: serializationPolicyName,\n        async sendRequest(request, next) {\n            const operationInfo = getOperationRequestInfo(request);\n            const operationSpec = operationInfo === null || operationInfo === void 0 ? void 0 : operationInfo.operationSpec;\n            const operationArguments = operationInfo === null || operationInfo === void 0 ? void 0 : operationInfo.operationArguments;\n            if (operationSpec && operationArguments) {\n                serializeHeaders(request, operationArguments, operationSpec);\n                serializeRequestBody(request, operationArguments, operationSpec, stringifyXML);\n            }\n            return next(request);\n        },\n    };\n}\n/**\n * @internal\n */\nexport function serializeHeaders(request, operationArguments, operationSpec) {\n    var _a, _b;\n    if (operationSpec.headerParameters) {\n        for (const headerParameter of operationSpec.headerParameters) {\n            let headerValue = getOperationArgumentValueFromParameter(operationArguments, headerParameter);\n            if ((headerValue !== null && headerValue !== undefined) || headerParameter.mapper.required) {\n                headerValue = operationSpec.serializer.serialize(headerParameter.mapper, headerValue, getPathStringFromParameter(headerParameter));\n                const headerCollectionPrefix = headerParameter.mapper\n                    .headerCollectionPrefix;\n                if (headerCollectionPrefix) {\n                    for (const key of Object.keys(headerValue)) {\n                        request.headers.set(headerCollectionPrefix + key, headerValue[key]);\n                    }\n                }\n                else {\n                    request.headers.set(headerParameter.mapper.serializedName || getPathStringFromParameter(headerParameter), headerValue);\n                }\n            }\n        }\n    }\n    const customHeaders = (_b = (_a = operationArguments.options) === null || _a === void 0 ? void 0 : _a.requestOptions) === null || _b === void 0 ? void 0 : _b.customHeaders;\n    if (customHeaders) {\n        for (const customHeaderName of Object.keys(customHeaders)) {\n            request.headers.set(customHeaderName, customHeaders[customHeaderName]);\n        }\n    }\n}\n/**\n * @internal\n */\nexport function serializeRequestBody(request, operationArguments, operationSpec, stringifyXML = function () {\n    throw new Error(\"XML serialization unsupported!\");\n}) {\n    var _a, _b, _c, _d, _e;\n    const serializerOptions = (_a = operationArguments.options) === null || _a === void 0 ? void 0 : _a.serializerOptions;\n    const updatedOptions = {\n        xml: {\n            rootName: (_b = serializerOptions === null || serializerOptions === void 0 ? void 0 : serializerOptions.xml.rootName) !== null && _b !== void 0 ? _b : \"\",\n            includeRoot: (_c = serializerOptions === null || serializerOptions === void 0 ? void 0 : serializerOptions.xml.includeRoot) !== null && _c !== void 0 ? _c : false,\n            xmlCharKey: (_d = serializerOptions === null || serializerOptions === void 0 ? void 0 : serializerOptions.xml.xmlCharKey) !== null && _d !== void 0 ? _d : XML_CHARKEY,\n        },\n    };\n    const xmlCharKey = updatedOptions.xml.xmlCharKey;\n    if (operationSpec.requestBody && operationSpec.requestBody.mapper) {\n        request.body = getOperationArgumentValueFromParameter(operationArguments, operationSpec.requestBody);\n        const bodyMapper = operationSpec.requestBody.mapper;\n        const { required, serializedName, xmlName, xmlElementName, xmlNamespace, xmlNamespacePrefix, nullable, } = bodyMapper;\n        const typeName = bodyMapper.type.name;\n        try {\n            if ((request.body !== undefined && request.body !== null) ||\n                (nullable && request.body === null) ||\n                required) {\n                const requestBodyParameterPathString = getPathStringFromParameter(operationSpec.requestBody);\n                request.body = operationSpec.serializer.serialize(bodyMapper, request.body, requestBodyParameterPathString, updatedOptions);\n                const isStream = typeName === MapperTypeNames.Stream;\n                if (operationSpec.isXML) {\n                    const xmlnsKey = xmlNamespacePrefix ? `xmlns:${xmlNamespacePrefix}` : \"xmlns\";\n                    const value = getXmlValueWithNamespace(xmlNamespace, xmlnsKey, typeName, request.body, updatedOptions);\n                    if (typeName === MapperTypeNames.Sequence) {\n                        request.body = stringifyXML(prepareXMLRootList(value, xmlElementName || xmlName || serializedName, xmlnsKey, xmlNamespace), { rootName: xmlName || serializedName, xmlCharKey });\n                    }\n                    else if (!isStream) {\n                        request.body = stringifyXML(value, {\n                            rootName: xmlName || serializedName,\n                            xmlCharKey,\n                        });\n                    }\n                }\n                else if (typeName === MapperTypeNames.String &&\n                    (((_e = operationSpec.contentType) === null || _e === void 0 ? void 0 : _e.match(\"text/plain\")) || operationSpec.mediaType === \"text\")) {\n                    // the String serializer has validated that request body is a string\n                    // so just send the string.\n                    return;\n                }\n                else if (!isStream) {\n                    request.body = JSON.stringify(request.body);\n                }\n            }\n        }\n        catch (error) {\n            throw new Error(`Error \"${error.message}\" occurred in serializing the payload - ${JSON.stringify(serializedName, undefined, \"  \")}.`);\n        }\n    }\n    else if (operationSpec.formDataParameters && operationSpec.formDataParameters.length > 0) {\n        request.formData = {};\n        for (const formDataParameter of operationSpec.formDataParameters) {\n            const formDataParameterValue = getOperationArgumentValueFromParameter(operationArguments, formDataParameter);\n            if (formDataParameterValue !== undefined && formDataParameterValue !== null) {\n                const formDataParameterPropertyName = formDataParameter.mapper.serializedName || getPathStringFromParameter(formDataParameter);\n                request.formData[formDataParameterPropertyName] = operationSpec.serializer.serialize(formDataParameter.mapper, formDataParameterValue, getPathStringFromParameter(formDataParameter), updatedOptions);\n            }\n        }\n    }\n}\n/**\n * Adds an xml namespace to the xml serialized object if needed, otherwise it just returns the value itself\n */\nfunction getXmlValueWithNamespace(xmlNamespace, xmlnsKey, typeName, serializedValue, options) {\n    // Composite and Sequence schemas already got their root namespace set during serialization\n    // We just need to add xmlns to the other schema types\n    if (xmlNamespace && ![\"Composite\", \"Sequence\", \"Dictionary\"].includes(typeName)) {\n        const result = {};\n        result[options.xml.xmlCharKey] = serializedValue;\n        result[XML_ATTRKEY] = { [xmlnsKey]: xmlNamespace };\n        return result;\n    }\n    return serializedValue;\n}\nfunction prepareXMLRootList(obj, elementName, xmlNamespaceKey, xmlNamespace) {\n    if (!Array.isArray(obj)) {\n        obj = [obj];\n    }\n    if (!xmlNamespaceKey || !xmlNamespace) {\n        return { [elementName]: obj };\n    }\n    const result = { [elementName]: obj };\n    result[XML_ATTRKEY] = { [xmlNamespaceKey]: xmlNamespace };\n    return result;\n}\n//# sourceMappingURL=serializationPolicy.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { deserializationPolicy } from \"./deserializationPolicy.js\";\nimport { bearerTokenAuthenticationPolicy, createPipelineFromOptions, } from \"@azure/core-rest-pipeline\";\nimport { serializationPolicy } from \"./serializationPolicy.js\";\n/**\n * Creates a new Pipeline for use with a Service Client.\n * Adds in deserializationPolicy by default.\n * Also adds in bearerTokenAuthenticationPolicy if passed a TokenCredential.\n * @param options - Options to customize the created pipeline.\n */\nexport function createClientPipeline(options = {}) {\n    const pipeline = createPipelineFromOptions(options !== null && options !== void 0 ? options : {});\n    if (options.credentialOptions) {\n        pipeline.addPolicy(bearerTokenAuthenticationPolicy({\n            credential: options.credentialOptions.credential,\n            scopes: options.credentialOptions.credentialScopes,\n        }));\n    }\n    pipeline.addPolicy(serializationPolicy(options.serializationOptions), { phase: \"Serialize\" });\n    pipeline.addPolicy(deserializationPolicy(options.deserializationOptions), {\n        phase: \"Deserialize\",\n    });\n    return pipeline;\n}\n//# sourceMappingURL=pipeline.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { createDefaultHttpClient } from \"@azure/core-rest-pipeline\";\nlet cachedHttpClient;\nexport function getCachedDefaultHttpClient() {\n    if (!cachedHttpClient) {\n        cachedHttpClient = createDefaultHttpClient();\n    }\n    return cachedHttpClient;\n}\n//# sourceMappingURL=httpClientCache.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { getOperationArgumentValueFromParameter } from \"./operationHelpers.js\";\nimport { getPathStringFromParameter } from \"./interfaceHelpers.js\";\nconst CollectionFormatToDelimiterMap = {\n    CSV: \",\",\n    SSV: \" \",\n    Multi: \"Multi\",\n    TSV: \"\\t\",\n    Pipes: \"|\",\n};\nexport function getRequestUrl(baseUri, operationSpec, operationArguments, fallbackObject) {\n    const urlReplacements = calculateUrlReplacements(operationSpec, operationArguments, fallbackObject);\n    let isAbsolutePath = false;\n    let requestUrl = replaceAll(baseUri, urlReplacements);\n    if (operationSpec.path) {\n        let path = replaceAll(operationSpec.path, urlReplacements);\n        // QUIRK: sometimes we get a path component like /{nextLink}\n        // which may be a fully formed URL with a leading /. In that case, we should\n        // remove the leading /\n        if (operationSpec.path === \"/{nextLink}\" && path.startsWith(\"/\")) {\n            path = path.substring(1);\n        }\n        // QUIRK: sometimes we get a path component like {nextLink}\n        // which may be a fully formed URL. In that case, we should\n        // ignore the baseUri.\n        if (isAbsoluteUrl(path)) {\n            requestUrl = path;\n            isAbsolutePath = true;\n        }\n        else {\n            requestUrl = appendPath(requestUrl, path);\n        }\n    }\n    const { queryParams, sequenceParams } = calculateQueryParameters(operationSpec, operationArguments, fallbackObject);\n    /**\n     * Notice that this call sets the `noOverwrite` parameter to true if the `requestUrl`\n     * is an absolute path. This ensures that existing query parameter values in `requestUrl`\n     * do not get overwritten. On the other hand when `requestUrl` is not absolute path, it\n     * is still being built so there is nothing to overwrite.\n     */\n    requestUrl = appendQueryParams(requestUrl, queryParams, sequenceParams, isAbsolutePath);\n    return requestUrl;\n}\nfunction replaceAll(input, replacements) {\n    let result = input;\n    for (const [searchValue, replaceValue] of replacements) {\n        result = result.split(searchValue).join(replaceValue);\n    }\n    return result;\n}\nfunction calculateUrlReplacements(operationSpec, operationArguments, fallbackObject) {\n    var _a;\n    const result = new Map();\n    if ((_a = operationSpec.urlParameters) === null || _a === void 0 ? void 0 : _a.length) {\n        for (const urlParameter of operationSpec.urlParameters) {\n            let urlParameterValue = getOperationArgumentValueFromParameter(operationArguments, urlParameter, fallbackObject);\n            const parameterPathString = getPathStringFromParameter(urlParameter);\n            urlParameterValue = operationSpec.serializer.serialize(urlParameter.mapper, urlParameterValue, parameterPathString);\n            if (!urlParameter.skipEncoding) {\n                urlParameterValue = encodeURIComponent(urlParameterValue);\n            }\n            result.set(`{${urlParameter.mapper.serializedName || parameterPathString}}`, urlParameterValue);\n        }\n    }\n    return result;\n}\nfunction isAbsoluteUrl(url) {\n    return url.includes(\"://\");\n}\nfunction appendPath(url, pathToAppend) {\n    if (!pathToAppend) {\n        return url;\n    }\n    const parsedUrl = new URL(url);\n    let newPath = parsedUrl.pathname;\n    if (!newPath.endsWith(\"/\")) {\n        newPath = `${newPath}/`;\n    }\n    if (pathToAppend.startsWith(\"/\")) {\n        pathToAppend = pathToAppend.substring(1);\n    }\n    const searchStart = pathToAppend.indexOf(\"?\");\n    if (searchStart !== -1) {\n        const path = pathToAppend.substring(0, searchStart);\n        const search = pathToAppend.substring(searchStart + 1);\n        newPath = newPath + path;\n        if (search) {\n            parsedUrl.search = parsedUrl.search ? `${parsedUrl.search}&${search}` : search;\n        }\n    }\n    else {\n        newPath = newPath + pathToAppend;\n    }\n    parsedUrl.pathname = newPath;\n    return parsedUrl.toString();\n}\nfunction calculateQueryParameters(operationSpec, operationArguments, fallbackObject) {\n    var _a;\n    const result = new Map();\n    const sequenceParams = new Set();\n    if ((_a = operationSpec.queryParameters) === null || _a === void 0 ? void 0 : _a.length) {\n        for (const queryParameter of operationSpec.queryParameters) {\n            if (queryParameter.mapper.type.name === \"Sequence\" && queryParameter.mapper.serializedName) {\n                sequenceParams.add(queryParameter.mapper.serializedName);\n            }\n            let queryParameterValue = getOperationArgumentValueFromParameter(operationArguments, queryParameter, fallbackObject);\n            if ((queryParameterValue !== undefined && queryParameterValue !== null) ||\n                queryParameter.mapper.required) {\n                queryParameterValue = operationSpec.serializer.serialize(queryParameter.mapper, queryParameterValue, getPathStringFromParameter(queryParameter));\n                const delimiter = queryParameter.collectionFormat\n                    ? CollectionFormatToDelimiterMap[queryParameter.collectionFormat]\n                    : \"\";\n                if (Array.isArray(queryParameterValue)) {\n                    // replace null and undefined\n                    queryParameterValue = queryParameterValue.map((item) => {\n                        if (item === null || item === undefined) {\n                            return \"\";\n                        }\n                        return item;\n                    });\n                }\n                if (queryParameter.collectionFormat === \"Multi\" && queryParameterValue.length === 0) {\n                    continue;\n                }\n                else if (Array.isArray(queryParameterValue) &&\n                    (queryParameter.collectionFormat === \"SSV\" || queryParameter.collectionFormat === \"TSV\")) {\n                    queryParameterValue = queryParameterValue.join(delimiter);\n                }\n                if (!queryParameter.skipEncoding) {\n                    if (Array.isArray(queryParameterValue)) {\n                        queryParameterValue = queryParameterValue.map((item) => {\n                            return encodeURIComponent(item);\n                        });\n                    }\n                    else {\n                        queryParameterValue = encodeURIComponent(queryParameterValue);\n                    }\n                }\n                // Join pipes and CSV *after* encoding, or the server will be upset.\n                if (Array.isArray(queryParameterValue) &&\n                    (queryParameter.collectionFormat === \"CSV\" || queryParameter.collectionFormat === \"Pipes\")) {\n                    queryParameterValue = queryParameterValue.join(delimiter);\n                }\n                result.set(queryParameter.mapper.serializedName || getPathStringFromParameter(queryParameter), queryParameterValue);\n            }\n        }\n    }\n    return {\n        queryParams: result,\n        sequenceParams,\n    };\n}\nfunction simpleParseQueryParams(queryString) {\n    const result = new Map();\n    if (!queryString || queryString[0] !== \"?\") {\n        return result;\n    }\n    // remove the leading ?\n    queryString = queryString.slice(1);\n    const pairs = queryString.split(\"&\");\n    for (const pair of pairs) {\n        const [name, value] = pair.split(\"=\", 2);\n        const existingValue = result.get(name);\n        if (existingValue) {\n            if (Array.isArray(existingValue)) {\n                existingValue.push(value);\n            }\n            else {\n                result.set(name, [existingValue, value]);\n            }\n        }\n        else {\n            result.set(name, value);\n        }\n    }\n    return result;\n}\n/** @internal */\nexport function appendQueryParams(url, queryParams, sequenceParams, noOverwrite = false) {\n    if (queryParams.size === 0) {\n        return url;\n    }\n    const parsedUrl = new URL(url);\n    // QUIRK: parsedUrl.searchParams will have their name/value pairs decoded, which\n    // can change their meaning to the server, such as in the case of a SAS signature.\n    // To avoid accidentally un-encoding a query param, we parse the key/values ourselves\n    const combinedParams = simpleParseQueryParams(parsedUrl.search);\n    for (const [name, value] of queryParams) {\n        const existingValue = combinedParams.get(name);\n        if (Array.isArray(existingValue)) {\n            if (Array.isArray(value)) {\n                existingValue.push(...value);\n                const valueSet = new Set(existingValue);\n                combinedParams.set(name, Array.from(valueSet));\n            }\n            else {\n                existingValue.push(value);\n            }\n        }\n        else if (existingValue) {\n            if (Array.isArray(value)) {\n                value.unshift(existingValue);\n            }\n            else if (sequenceParams.has(name)) {\n                combinedParams.set(name, [existingValue, value]);\n            }\n            if (!noOverwrite) {\n                combinedParams.set(name, value);\n            }\n        }\n        else {\n            combinedParams.set(name, value);\n        }\n    }\n    const searchPieces = [];\n    for (const [name, value] of combinedParams) {\n        if (typeof value === \"string\") {\n            searchPieces.push(`${name}=${value}`);\n        }\n        else if (Array.isArray(value)) {\n            // QUIRK: If we get an array of values, include multiple key/value pairs\n            for (const subValue of value) {\n                searchPieces.push(`${name}=${subValue}`);\n            }\n        }\n        else {\n            searchPieces.push(`${name}=${value}`);\n        }\n    }\n    // QUIRK: we have to set search manually as searchParams will encode comma when it shouldn't.\n    parsedUrl.search = searchPieces.length ? `?${searchPieces.join(\"&\")}` : \"\";\n    return parsedUrl.toString();\n}\n//# sourceMappingURL=urlHelpers.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { createClientLogger } from \"@azure/logger\";\nexport const logger = createClientLogger(\"core-client\");\n//# sourceMappingURL=log.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { createPipelineRequest, } from \"@azure/core-rest-pipeline\";\nimport { createClientPipeline } from \"./pipeline.js\";\nimport { flattenResponse } from \"./utils.js\";\nimport { getCachedDefaultHttpClient } from \"./httpClientCache.js\";\nimport { getOperationRequestInfo } from \"./operationHelpers.js\";\nimport { getRequestUrl } from \"./urlHelpers.js\";\nimport { getStreamingResponseStatusCodes } from \"./interfaceHelpers.js\";\nimport { logger } from \"./log.js\";\n/**\n * Initializes a new instance of the ServiceClient.\n */\nexport class ServiceClient {\n    /**\n     * The ServiceClient constructor\n     * @param credential - The credentials used for authentication with the service.\n     * @param options - The service client options that govern the behavior of the client.\n     */\n    constructor(options = {}) {\n        var _a, _b;\n        this._requestContentType = options.requestContentType;\n        this._endpoint = (_a = options.endpoint) !== null && _a !== void 0 ? _a : options.baseUri;\n        if (options.baseUri) {\n            logger.warning(\"The baseUri option for SDK Clients has been deprecated, please use endpoint instead.\");\n        }\n        this._allowInsecureConnection = options.allowInsecureConnection;\n        this._httpClient = options.httpClient || getCachedDefaultHttpClient();\n        this.pipeline = options.pipeline || createDefaultPipeline(options);\n        if ((_b = options.additionalPolicies) === null || _b === void 0 ? void 0 : _b.length) {\n            for (const { policy, position } of options.additionalPolicies) {\n                // Sign happens after Retry and is commonly needed to occur\n                // before policies that intercept post-retry.\n                const afterPhase = position === \"perRetry\" ? \"Sign\" : undefined;\n                this.pipeline.addPolicy(policy, {\n                    afterPhase,\n                });\n            }\n        }\n    }\n    /**\n     * Send the provided httpRequest.\n     */\n    async sendRequest(request) {\n        return this.pipeline.sendRequest(this._httpClient, request);\n    }\n    /**\n     * Send an HTTP request that is populated using the provided OperationSpec.\n     * @typeParam T - The typed result of the request, based on the OperationSpec.\n     * @param operationArguments - The arguments that the HTTP request's templated values will be populated from.\n     * @param operationSpec - The OperationSpec to use to populate the httpRequest.\n     */\n    async sendOperationRequest(operationArguments, operationSpec) {\n        const endpoint = operationSpec.baseUrl || this._endpoint;\n        if (!endpoint) {\n            throw new Error(\"If operationSpec.baseUrl is not specified, then the ServiceClient must have a endpoint string property that contains the base URL to use.\");\n        }\n        // Templatized URLs sometimes reference properties on the ServiceClient child class,\n        // so we have to pass `this` below in order to search these properties if they're\n        // not part of OperationArguments\n        const url = getRequestUrl(endpoint, operationSpec, operationArguments, this);\n        const request = createPipelineRequest({\n            url,\n        });\n        request.method = operationSpec.httpMethod;\n        const operationInfo = getOperationRequestInfo(request);\n        operationInfo.operationSpec = operationSpec;\n        operationInfo.operationArguments = operationArguments;\n        const contentType = operationSpec.contentType || this._requestContentType;\n        if (contentType && operationSpec.requestBody) {\n            request.headers.set(\"Content-Type\", contentType);\n        }\n        const options = operationArguments.options;\n        if (options) {\n            const requestOptions = options.requestOptions;\n            if (requestOptions) {\n                if (requestOptions.timeout) {\n                    request.timeout = requestOptions.timeout;\n                }\n                if (requestOptions.onUploadProgress) {\n                    request.onUploadProgress = requestOptions.onUploadProgress;\n                }\n                if (requestOptions.onDownloadProgress) {\n                    request.onDownloadProgress = requestOptions.onDownloadProgress;\n                }\n                if (requestOptions.shouldDeserialize !== undefined) {\n                    operationInfo.shouldDeserialize = requestOptions.shouldDeserialize;\n                }\n                if (requestOptions.allowInsecureConnection) {\n                    request.allowInsecureConnection = true;\n                }\n            }\n            if (options.abortSignal) {\n                request.abortSignal = options.abortSignal;\n            }\n            if (options.tracingOptions) {\n                request.tracingOptions = options.tracingOptions;\n            }\n        }\n        if (this._allowInsecureConnection) {\n            request.allowInsecureConnection = true;\n        }\n        if (request.streamResponseStatusCodes === undefined) {\n            request.streamResponseStatusCodes = getStreamingResponseStatusCodes(operationSpec);\n        }\n        try {\n            const rawResponse = await this.sendRequest(request);\n            const flatResponse = flattenResponse(rawResponse, operationSpec.responses[rawResponse.status]);\n            if (options === null || options === void 0 ? void 0 : options.onResponse) {\n                options.onResponse(rawResponse, flatResponse);\n            }\n            return flatResponse;\n        }\n        catch (error) {\n            if (typeof error === \"object\" && (error === null || error === void 0 ? void 0 : error.response)) {\n                const rawResponse = error.response;\n                const flatResponse = flattenResponse(rawResponse, operationSpec.responses[error.statusCode] || operationSpec.responses[\"default\"]);\n                error.details = flatResponse;\n                if (options === null || options === void 0 ? void 0 : options.onResponse) {\n                    options.onResponse(rawResponse, flatResponse, error);\n                }\n            }\n            throw error;\n        }\n    }\n}\nfunction createDefaultPipeline(options) {\n    const credentialScopes = getCredentialScopes(options);\n    const credentialOptions = options.credential && credentialScopes\n        ? { credentialScopes, credential: options.credential }\n        : undefined;\n    return createClientPipeline(Object.assign(Object.assign({}, options), { credentialOptions }));\n}\nfunction getCredentialScopes(options) {\n    if (options.credentialScopes) {\n        return options.credentialScopes;\n    }\n    if (options.endpoint) {\n        return `${options.endpoint}/.default`;\n    }\n    if (options.baseUri) {\n        return `${options.baseUri}/.default`;\n    }\n    if (options.credential && !options.credentialScopes) {\n        throw new Error(`When using credentials, the ServiceClientOptions must contain either a endpoint or a credentialScopes. Unable to create a bearerTokenAuthenticationPolicy`);\n    }\n    return undefined;\n}\n//# sourceMappingURL=serviceClient.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { logger as coreClientLogger } from \"./log.js\";\nimport { decodeStringToString } from \"./base64.js\";\n/**\n * Converts: `Bearer a=\"b\", c=\"d\", Bearer d=\"e\", f=\"g\"`.\n * Into: `[ { a: 'b', c: 'd' }, { d: 'e', f: 'g' } ]`.\n *\n * @internal\n */\nexport function parseCAEChallenge(challenges) {\n    const bearerChallenges = `, ${challenges.trim()}`.split(\", Bearer \").filter((x) => x);\n    return bearerChallenges.map((challenge) => {\n        const challengeParts = `${challenge.trim()}, `.split('\", ').filter((x) => x);\n        const keyValuePairs = challengeParts.map((keyValue) => (([key, value]) => ({ [key]: value }))(keyValue.trim().split('=\"')));\n        // Key-value pairs to plain object:\n        return keyValuePairs.reduce((a, b) => (Object.assign(Object.assign({}, a), b)), {});\n    });\n}\n/**\n * This function can be used as a callback for the `bearerTokenAuthenticationPolicy` of `@azure/core-rest-pipeline`, to support CAE challenges:\n * [Continuous Access Evaluation](https://docs.microsoft.com/azure/active-directory/conditional-access/concept-continuous-access-evaluation).\n *\n * Call the `bearerTokenAuthenticationPolicy` with the following options:\n *\n * ```ts\n * import { bearerTokenAuthenticationPolicy } from \"@azure/core-rest-pipeline\";\n * import { authorizeRequestOnClaimChallenge } from \"@azure/core-client\";\n *\n * const bearerTokenAuthenticationPolicy = bearerTokenAuthenticationPolicy({\n *   authorizeRequestOnChallenge: authorizeRequestOnClaimChallenge\n * });\n * ```\n *\n * Once provided, the `bearerTokenAuthenticationPolicy` policy will internally handle Continuous Access Evaluation (CAE) challenges.\n * When it can't complete a challenge it will return the 401 (unauthorized) response from ARM.\n *\n * Example challenge with claims:\n *\n * ```\n * Bearer authorization_uri=\"https://login.windows-ppe.net/\", error=\"invalid_token\",\n * error_description=\"User session has been revoked\",\n * claims=\"eyJhY2Nlc3NfdG9rZW4iOnsibmJmIjp7ImVzc2VudGlhbCI6dHJ1ZSwgInZhbHVlIjoiMTYwMzc0MjgwMCJ9fX0=\"\n * ```\n */\nexport async function authorizeRequestOnClaimChallenge(onChallengeOptions) {\n    const { scopes, response } = onChallengeOptions;\n    const logger = onChallengeOptions.logger || coreClientLogger;\n    const challenge = response.headers.get(\"WWW-Authenticate\");\n    if (!challenge) {\n        logger.info(`The WWW-Authenticate header was missing. Failed to perform the Continuous Access Evaluation authentication flow.`);\n        return false;\n    }\n    const challenges = parseCAEChallenge(challenge) || [];\n    const parsedChallenge = challenges.find((x) => x.claims);\n    if (!parsedChallenge) {\n        logger.info(`The WWW-Authenticate header was missing the necessary \"claims\" to perform the Continuous Access Evaluation authentication flow.`);\n        return false;\n    }\n    const accessToken = await onChallengeOptions.getAccessToken(parsedChallenge.scope ? [parsedChallenge.scope] : scopes, {\n        claims: decodeStringToString(parsedChallenge.claims),\n    });\n    if (!accessToken) {\n        return false;\n    }\n    onChallengeOptions.request.headers.set(\"Authorization\", `Bearer ${accessToken.token}`);\n    return true;\n}\n//# sourceMappingURL=authorizeRequestOnClaimChallenge.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\n/**\n * A set of constants used internally when processing requests.\n */\nconst Constants = {\n    DefaultScope: \"/.default\",\n    /**\n     * Defines constants for use with HTTP headers.\n     */\n    HeaderConstants: {\n        /**\n         * The Authorization header.\n         */\n        AUTHORIZATION: \"authorization\",\n    },\n};\nfunction isUuid(text) {\n    return /^[0-9a-fA-F]{8}\\b-[0-9a-fA-F]{4}\\b-[0-9a-fA-F]{4}\\b-[0-9a-fA-F]{4}\\b-[0-9a-fA-F]{12}$/.test(text);\n}\n/**\n * Defines a callback to handle auth challenge for Storage APIs.\n * This implements the bearer challenge process described here: https://docs.microsoft.com/rest/api/storageservices/authorize-with-azure-active-directory#bearer-challenge\n * Handling has specific features for storage that departs to the general AAD challenge docs.\n **/\nexport const authorizeRequestOnTenantChallenge = async (challengeOptions) => {\n    const requestOptions = requestToOptions(challengeOptions.request);\n    const challenge = getChallenge(challengeOptions.response);\n    if (challenge) {\n        const challengeInfo = parseChallenge(challenge);\n        const challengeScopes = buildScopes(challengeOptions, challengeInfo);\n        const tenantId = extractTenantId(challengeInfo);\n        if (!tenantId) {\n            return false;\n        }\n        const accessToken = await challengeOptions.getAccessToken(challengeScopes, Object.assign(Object.assign({}, requestOptions), { tenantId }));\n        if (!accessToken) {\n            return false;\n        }\n        challengeOptions.request.headers.set(Constants.HeaderConstants.AUTHORIZATION, `Bearer ${accessToken.token}`);\n        return true;\n    }\n    return false;\n};\n/**\n * Extracts the tenant id from the challenge information\n * The tenant id is contained in the authorization_uri as the first\n * path part.\n */\nfunction extractTenantId(challengeInfo) {\n    const parsedAuthUri = new URL(challengeInfo.authorization_uri);\n    const pathSegments = parsedAuthUri.pathname.split(\"/\");\n    const tenantId = pathSegments[1];\n    if (tenantId && isUuid(tenantId)) {\n        return tenantId;\n    }\n    return undefined;\n}\n/**\n * Builds the authentication scopes based on the information that comes in the\n * challenge information. Scopes url is present in the resource_id, if it is empty\n * we keep using the original scopes.\n */\nfunction buildScopes(challengeOptions, challengeInfo) {\n    if (!challengeInfo.resource_id) {\n        return challengeOptions.scopes;\n    }\n    const challengeScopes = new URL(challengeInfo.resource_id);\n    challengeScopes.pathname = Constants.DefaultScope;\n    let scope = challengeScopes.toString();\n    if (scope === \"https://disk.azure.com/.default\") {\n        // the extra slash is required by the service\n        scope = \"https://disk.azure.com//.default\";\n    }\n    return [scope];\n}\n/**\n * We will retrieve the challenge only if the response status code was 401,\n * and if the response contained the header \"WWW-Authenticate\" with a non-empty value.\n */\nfunction getChallenge(response) {\n    const challenge = response.headers.get(\"WWW-Authenticate\");\n    if (response.status === 401 && challenge) {\n        return challenge;\n    }\n    return;\n}\n/**\n * Converts: `Bearer a=\"b\" c=\"d\"`.\n * Into: `[ { a: 'b', c: 'd' }]`.\n *\n * @internal\n */\nfunction parseChallenge(challenge) {\n    const bearerChallenge = challenge.slice(\"Bearer \".length);\n    const challengeParts = `${bearerChallenge.trim()} `.split(\" \").filter((x) => x);\n    const keyValuePairs = challengeParts.map((keyValue) => (([key, value]) => ({ [key]: value }))(keyValue.trim().split(\"=\")));\n    // Key-value pairs to plain object:\n    return keyValuePairs.reduce((a, b) => (Object.assign(Object.assign({}, a), b)), {});\n}\n/**\n * Extracts the options form a Pipeline Request for later re-use\n */\nfunction requestToOptions(request) {\n    return {\n        abortSignal: request.abortSignal,\n        requestOptions: {\n            timeout: request.timeout,\n        },\n        tracingOptions: request.tracingOptions,\n    };\n}\n//# sourceMappingURL=authorizeRequestOnTenantChallenge.js.map"],"names":["AzureKeyCredential","key","this","_key","constructor","Error","update","newKey","isTokenCredential","credential","castCredential","getToken","undefined","signRequest","length","encodeByteArray","value","str","i","String","fromCharCode","btoa","decodeString","byteString","atob","arr","Uint8Array","charCodeAt","XML_ATTRKEY","XML_CHARKEY","validateISODuration","validUuidRegex","flattenResponse","fullResponse","responseSpec","_a","_b","parsedHeaders","request","method","Object","assign","body","parsedBody","bodyMapper","isNullable","Boolean","nullable","expectedBodyTypeName","type","name","blobBody","readableStreamBody","modelProperties","isPageableResponse","keys","some","k","serializedName","arrayResponse","getOwnPropertyNames","responseObject","combinedHeadersAndBody","headers","hasNullableType","shouldWrapBody","handleNullableResponseAndWrappableBody","mapperTypeName","match","SerializerImpl","modelMappers","isXML","validateConstraints","mapper","objectName","failValidation","constraintName","constraintValue","constraints","ExclusiveMaximum","ExclusiveMinimum","InclusiveMaximum","InclusiveMinimum","MaxItems","MaxLength","MinItems","MinLength","MultipleOf","Pattern","UniqueItems","pattern","RegExp","item","ar","indexOf","serialize","object","options","xml","_c","updatedOptions","rootName","includeRoot","xmlCharKey","payload","mapperType","isConstant","defaultValue","required","typeName","valueOf","uuid","test","objectType","pipe","tee","ArrayBuffer","isView","Blob","serializeBasicTypes","allowedValues","toLowerCase","JSON","stringify","serializeEnumType","Date","isNaN","parse","toISOString","substring","toUTCString","d","Math","floor","getTime","dateToUnixTime","isDuration","serializeDateTypes","serializeByteArrayType","buffer","ch","len","substr","trimEnd","replace","bufferToBase64Url","serializeBase64UrlType","serializer","isXml","Array","isArray","elementType","element","className","tempArray","serializedValue","xmlNamespace","xmlnsKey","xmlNamespacePrefix","serializeSequenceType","valueType","tempDictionary","getXmlObjectValue","result","serializeDictionaryType","getPolymorphicDiscriminatorRecursively","getPolymorphicMapper","modelProps","resolveModelProperties","propertyMapper","readOnly","propName","parentObject","xmlIsWrapped","xmlName","xmlElementName","paths","splitSerializeName","pop","pathName","childObject","propertyObjectName","toSerialize","polymorphicDiscriminator","clientName","xmlIsAttribute","additionalPropertiesMapper","additionalProperties","modelMapper","resolveReferencedMapper","resolveAdditionalProperties","propNames","clientPropName","every","pn","serializeCompositeType","deserialize","responseBody","_d","ignoreUnknownProperties","instance","handledPropertyNames","push","headerCollectionPrefix","dictionary","headerKey","startsWith","xmlIsMsText","propertyName","wrapped","elementList","property","propertyInstance","res","steps","arrayInstance","v","entries","prototype","hasOwnProperty","call","isAdditionalProperty","responsePropName","includes","isSpecialXmlProperty","deserializeCompositeType","parseFloat","n","unixTimeToDate","base64UrlToByteArray","deserializeSequenceType","deserializeDictionaryType","createSerializer","prop","classes","partialclass","subwords","split","charAt","polymorphicPropertyName","discriminatorName","discriminatorValue","uberParent","polymorphicMapper","discriminators","typeNamesToCheck","currentName","shift","indexDiscriminator","getIndexDiscriminator","getPolymorphicDiscriminatorSafely","MapperTypeNames","Base64Url","ByteArray","Composite","DateTime","DateTimeRfc1123","Dictionary","Enum","Number","Sequence","Stream","TimeSpan","UnixTime","state","operationRequestMap","WeakMap","getOperationArgumentValueFromParameter","operationArguments","parameter","fallbackObject","parameterPath","parameterMapper","propertySearchResult","getPropertyFromParameterPath","propertyFound","useDefaultValue","propertyValue","parent","parameterPathPart","originalRequestSymbol","Symbol","for","getOperationRequestInfo","hasOriginalRequest","info","get","set","defaultJsonContentTypes","defaultXmlContentTypes","deserializationPolicyName","deserializationPolicy","_e","_f","_g","jsonContentTypes","expectedContentTypes","json","xmlContentTypes","parseXML","serializerOptions","sendRequest","next","response","async","parsedResponse","operationResponse","opts","streamResponseStatusCodes","has","status","bodyAsText","text","contentType","contentComponents","map","component","err","msg","errCode","code","RestError","statusCode","operationInfo","shouldDeserialize","shouldDeserializeResponse","operationSpec","responses","operationResponseGetter","getOperationResponseMap","error","shouldReturnResponse","isSuccessByStatus","isExpectedStatusCode","expectedStatusCodes","isOperationSpecEmpty","isError","errorResponseSpec","default","initialErrorMessage","defaultBodyMapper","defaultHeadersMapper","headersMapper","deserializedError","valueToDeserialize","elementName","internalError","message","toJSON","defaultError","handleErrorResponse","deserializeError","httpMethod","deserializeResponseBody","getPathStringFromParameter","join","serializationPolicyName","serializationPolicy","stringifyXML","headerParameters","headerParameter","headerValue","customHeaders","requestOptions","customHeaderName","serializeHeaders","requestBody","requestBodyParameterPathString","isStream","getXmlValueWithNamespace","obj","xmlNamespaceKey","prepareXMLRootList","mediaType","formDataParameters","formData","formDataParameter","formDataParameterValue","formDataParameterPropertyName","serializeRequestBody","createClientPipeline","pipeline","createPipelineFromOptions","credentialOptions","addPolicy","bearerTokenAuthenticationPolicy","scopes","credentialScopes","serializationOptions","phase","deserializationOptions","cachedHttpClient","CollectionFormatToDelimiterMap","CSV","SSV","Multi","TSV","Pipes","getRequestUrl","baseUri","urlReplacements","Map","urlParameters","urlParameter","urlParameterValue","parameterPathString","skipEncoding","encodeURIComponent","calculateUrlReplacements","isAbsolutePath","requestUrl","replaceAll","path","url","pathToAppend","parsedUrl","URL","newPath","pathname","endsWith","searchStart","search","toString","appendPath","queryParams","sequenceParams","Set","queryParameters","queryParameter","add","queryParameterValue","delimiter","collectionFormat","calculateQueryParameters","noOverwrite","size","combinedParams","queryString","pairs","slice","pair","existingValue","simpleParseQueryParams","valueSet","from","unshift","searchPieces","subValue","appendQueryParams","input","replacements","searchValue","replaceValue","createClientLogger","ServiceClient","_requestContentType","requestContentType","_endpoint","endpoint","_allowInsecureConnection","allowInsecureConnection","_httpClient","httpClient","createDefaultHttpClient","getCredentialScopes","createDefaultPipeline","additionalPolicies","policy","position","afterPhase","sendOperationRequest","baseUrl","createPipelineRequest","timeout","onUploadProgress","onDownloadProgress","abortSignal","tracingOptions","getStreamingResponseStatusCodes","rawResponse","flatResponse","onResponse","details","authorizeRequestOnClaimChallenge","onChallengeOptions","logger","challenge","challenges","trim","filter","x","keyValue","reduce","a","b","parseCAEChallenge","parsedChallenge","find","claims","accessToken","getAccessToken","scope","token","Constants","AUTHORIZATION","authorizeRequestOnTenantChallenge","challengeOptions","getChallenge","challengeInfo","bearerChallenge","challengeParts","parseChallenge","challengeScopes","resource_id","buildScopes","tenantId","parsedAuthUri","authorization_uri","extractTenantId"],"sourceRoot":""}