{"version":3,"file":"static/js/6320_615fe2a60d9c56de070d.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.7.3/node_modules/@azure/core-client/dist-esm/src/interfaces.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-client@1.7.3/node_modules/@azure/core-client/dist-esm/src/base64.browser.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-client@1.7.3/node_modules/@azure/core-client/dist-esm/src/serializer.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-client@1.7.3/node_modules/@azure/core-client/dist-esm/src/operationHelpers.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-client@1.7.3/node_modules/@azure/core-client/dist-esm/src/deserializationPolicy.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-client@1.7.3/node_modules/@azure/core-client/dist-esm/src/interfaceHelpers.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-client@1.7.3/node_modules/@azure/core-client/dist-esm/src/serializationPolicy.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-client@1.7.3/node_modules/@azure/core-client/dist-esm/src/httpClientCache.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-client@1.7.3/node_modules/@azure/core-client/dist-esm/src/urlHelpers.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-client@1.7.3/node_modules/@azure/core-client/dist-esm/src/log.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-client@1.7.3/node_modules/@azure/core-client/dist-esm/src/serviceClient.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-client@1.7.3/node_modules/@azure/core-client/dist-esm/src/pipeline.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-client@1.7.3/node_modules/@azure/core-client/dist-esm/src/utils.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 * 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 * Encodes a string in base64 format.\n * @param value - the string to encode\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 */\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 */\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 */\nexport function decodeStringToString(value) {\n    return atob(value);\n}\n//# sourceMappingURL=base64.browser.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport * as base64 from \"./base64\";\nimport { XML_ATTRKEY, XML_CHARKEY, } from \"./interfaces\";\nimport { isDuration, isValidUuid } from \"./utils\";\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\" &&\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, NodeJS.ReadableStream, or () => NodeJS.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 * @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 operationRequestMap = new WeakMap();\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 = operationRequestMap.get(request);\n    if (!info) {\n        info = {};\n        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\";\nimport { RestError, } from \"@azure/core-rest-pipeline\";\nimport { MapperTypeNames } from \"./serializer\";\nimport { getOperationRequestInfo } from \"./operationHelpers\";\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\";\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\";\nimport { getOperationArgumentValueFromParameter, getOperationRequestInfo, } from \"./operationHelpers\";\nimport { MapperTypeNames } from \"./serializer\";\nimport { getPathStringFromParameter } from \"./interfaceHelpers\";\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 { 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\";\nimport { getPathStringFromParameter } from \"./interfaceHelpers\";\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\";\nimport { flattenResponse } from \"./utils\";\nimport { getCachedDefaultHttpClient } from \"./httpClientCache\";\nimport { getOperationRequestInfo } from \"./operationHelpers\";\nimport { getRequestUrl } from \"./urlHelpers\";\nimport { getStreamingResponseStatusCodes } from \"./interfaceHelpers\";\nimport { logger } from \"./log\";\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 { deserializationPolicy } from \"./deserializationPolicy\";\nimport { bearerTokenAuthenticationPolicy, createPipelineFromOptions, } from \"@azure/core-rest-pipeline\";\nimport { serializationPolicy } from \"./serializationPolicy\";\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.\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"],"names":["AzureKeyCredential","key","this","_key","constructor","Error","update","newKey","isTokenCredential","credential","castCredential","getToken","undefined","signRequest","length","XML_ATTRKEY","XML_CHARKEY","encodeByteArray","value","str","i","String","fromCharCode","btoa","decodeString","byteString","atob","arr","Uint8Array","charCodeAt","SerializerImpl","modelMappers","isXML","validateConstraints","mapper","objectName","failValidation","constraintName","constraintValue","constraints","ExclusiveMaximum","ExclusiveMinimum","InclusiveMaximum","InclusiveMinimum","MaxItems","MaxLength","MinItems","MinLength","MultipleOf","Pattern","UniqueItems","pattern","RegExp","match","some","item","ar","indexOf","serialize","object","options","xml","_a","_b","_c","updatedOptions","rootName","includeRoot","xmlCharKey","payload","mapperType","type","name","serializedName","isConstant","defaultValue","required","nullable","typeName","valueOf","objectType","pipe","ArrayBuffer","isView","Blob","serializeBasicTypes","allowedValues","toLowerCase","JSON","stringify","serializeEnumType","Date","isNaN","parse","toISOString","substring","toUTCString","d","Math","floor","getTime","dateToUnixTime","serializeDateTypes","serializeByteArrayType","buffer","ch","len","substr","trimEnd","replace","bufferToBase64Url","serializeBase64UrlType","serializer","isXml","Array","isArray","elementType","element","className","tempArray","serializedValue","xmlNamespace","xmlnsKey","xmlNamespacePrefix","Object","assign","serializeSequenceType","Boolean","valueType","tempDictionary","keys","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","k","v","entries","prototype","hasOwnProperty","call","isAdditionalProperty","responsePropName","includes","isSpecialXmlProperty","deserializeCompositeType","parseFloat","n","unixTimeToDate","base64UrlToByteArray","deserializeSequenceType","deserializeDictionaryType","createSerializer","prop","classes","partialclass","subwords","split","charAt","modelProperties","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","getOperationArgumentValueFromParameter","operationArguments","parameter","fallbackObject","parameterPath","parameterMapper","propertySearchResult","getPropertyFromParameterPath","propertyFound","useDefaultValue","propertyValue","parent","parameterPathPart","operationRequestMap","WeakMap","originalRequestSymbol","Symbol","for","getOperationRequestInfo","request","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","headers","contentComponents","map","component","parsedBody","body","err","msg","errCode","code","statusCode","operationInfo","shouldDeserialize","shouldDeserializeResponse","operationSpec","responses","responseSpec","operationResponseGetter","getOperationResponseMap","error","shouldReturnResponse","isSuccessByStatus","isExpectedStatusCode","expectedStatusCodes","isOperationSpecEmpty","isError","errorResponseSpec","default","initialErrorMessage","defaultBodyMapper","bodyMapper","defaultHeadersMapper","headersMapper","deserializedError","valueToDeserialize","elementName","internalError","message","parsedHeaders","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","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","logger","createClientLogger","ServiceClient","_requestContentType","requestContentType","_endpoint","endpoint","warning","_allowInsecureConnection","allowInsecureConnection","_httpClient","httpClient","pipeline","credentialScopes","getCredentialScopes","credentialOptions","createPipelineFromOptions","addPolicy","bearerTokenAuthenticationPolicy","scopes","serializationOptions","phase","deserializationOptions","createClientPipeline","createDefaultPipeline","additionalPolicies","policy","position","afterPhase","sendOperationRequest","baseUrl","method","timeout","onUploadProgress","onDownloadProgress","abortSignal","tracingOptions","getStreamingResponseStatusCodes","rawResponse","flatResponse","onResponse","details","validateISODuration","isDuration","test","validUuidRegex","isValidUuid","uuid","flattenResponse","fullResponse","isNullable","expectedBodyTypeName","blobBody","readableStreamBody","isPageableResponse","arrayResponse","getOwnPropertyNames","responseObject","combinedHeadersAndBody","hasNullableType","shouldWrapBody","handleNullableResponseAndWrappableBody","mapperTypeName"],"sourceRoot":""}