@salable/sdk 1.0.42 → 1.0.43

package/dist/index.es.js

@@ -407,21 +407,21 @@ const deserializeIntoUntypedNode = (untypedNode = {}) => {
  * @param node The object to check.
  * @returns boolean indicating if the node is an UntypedNumber.
  */
-function isUntypedNumber(node) {
+const isUntypedNumber = (node) => {
     const proposedNode = node;
     return proposedNode && typeof proposedNode.value === "number";
-}
+};
 /**
  * Factory to create an UntypedNumber from a number.
  * @param value The number value to create from.
  * @returns The created UntypedNumber.
  */
-function createUntypedNumber(value) {
+const createUntypedNumber = (value) => {
     return {
         value,
         getValue: () => value,
     };
-}
+};
 
 /**
  * -------------------------------------------------------------------------------------------
@@ -455,19 +455,19 @@ const createUntypedArray = (value) => {
  * @param node The object to check.
  * @returns boolean indicating if the node is an UntypedNull.
  */
-function isUntypedNull(node) {
+const isUntypedNull = (node) => {
     return node.value === null;
-}
+};
 /**
- * Factory to create an UntypedNull from a boolean.
+ * Factory to create an UntypedNull.
  * @returns The created UntypedNull.
  */
-function createUntypedNull() {
+const createUntypedNull = () => {
     return {
         value: null,
         getValue: () => null,
     };
-}
+};
 
 /**
  * -------------------------------------------------------------------------------------------
@@ -501,42 +501,42 @@ const createUntypedObject = (value) => {
  * @param node The object to check.
  * @returns boolean indicating if the node is an UntypedString.
  */
-function isUntypedString(node) {
+const isUntypedString = (node) => {
     const proposedNode = node;
     return proposedNode && typeof proposedNode.value === "string";
-}
+};
 /**
  * Factory to create an UntypedString from a string.
  * @param value The string value to create from.
  * @returns The created UntypedString.
  */
-function createUntypedString(value) {
+const createUntypedString = (value) => {
     return {
         value,
         getValue: () => value,
     };
-}
+};
 
 /**
  * Type guard to assert that an UntypedNode instance is an UntypedBoolean.
  * @param node The UntypedNode to check.
  * @returns boolean indicating if the node is an UntypedBoolean.
  */
-function isUntypedBoolean(node) {
+const isUntypedBoolean = (node) => {
     const proposedNode = node;
     return proposedNode && typeof proposedNode.value === "boolean";
-}
+};
 /**
  * Factory to create an UntypedBoolean from a boolean.
  * @param value The boolean value to create from.
  * @returns The created UntypedBoolean.
  */
-function createUntypedBoolean(value) {
+const createUntypedBoolean = (value) => {
     return {
         value,
         getValue: () => value,
     };
-}
+};
 
 /**
  * -------------------------------------------------------------------------------------------
@@ -790,10 +790,10 @@ const BackingStoreKey = "backingStoreEnabled";
  * @param fields The fields of the object
  * @returns boolean indicating if the object is a BackedModel
  */
-function isBackingStoreEnabled(fields) {
+const isBackingStoreEnabled = (fields) => {
     // Check if the fields contain the backing store key
     return Object.keys(fields).includes(BackingStoreKey);
-}
+};
 
 /**
  * -------------------------------------------------------------------------------------------
@@ -808,7 +808,7 @@ function isBackingStoreEnabled(fields) {
  * @param original The serialization writer to enable the backing store on.
  * @returns A new serialization writer with the backing store enabled.
  */
-function enableBackingStoreForSerializationWriterFactory(serializationWriterFactoryRegistry, parseNodeFactoryRegistry, original) {
+const enableBackingStoreForSerializationWriterFactory = (serializationWriterFactoryRegistry, parseNodeFactoryRegistry, original) => {
     if (!original)
         throw new Error("Original must be specified");
     let result = original;
@@ -821,14 +821,14 @@ function enableBackingStoreForSerializationWriterFactory(serializationWriterFact
     enableBackingStoreForSerializationRegistry(serializationWriterFactoryRegistry);
     enableBackingStoreForParseNodeRegistry(parseNodeFactoryRegistry);
     return result;
-}
+};
 /**
  * Enables the backing store on default parse node factories and the given parse node factory.
  * @param parseNodeFactoryRegistry The parse node factory registry to enable the backing store on.
  * @param original The parse node factory to enable the backing store on.
  * @returns A new parse node factory with the backing store enabled.
  */
-function enableBackingStoreForParseNodeFactory(parseNodeFactoryRegistry, original) {
+const enableBackingStoreForParseNodeFactory = (parseNodeFactoryRegistry, original) => {
     if (!original)
         throw new Error("Original must be specified");
     let result = original;
@@ -840,29 +840,29 @@ function enableBackingStoreForParseNodeFactory(parseNodeFactoryRegistry, origina
     }
     enableBackingStoreForParseNodeRegistry(parseNodeFactoryRegistry);
     return result;
-}
+};
 /**
  * Enables the backing store on the given parse node factory registry.
  * @param registry The parse node factory registry to enable the backing store on.
  */
-function enableBackingStoreForParseNodeRegistry(registry) {
+const enableBackingStoreForParseNodeRegistry = (registry) => {
     for (const [k, v] of registry.contentTypeAssociatedFactories) {
         if (!(v instanceof BackingStoreParseNodeFactory || v instanceof ParseNodeFactoryRegistry)) {
             registry.contentTypeAssociatedFactories.set(k, new BackingStoreParseNodeFactory(v));
         }
     }
-}
+};
 /**
  * Enables the backing store on the given serialization factory registry.
  * @param registry The serialization factory registry to enable the backing store on.
  */
-function enableBackingStoreForSerializationRegistry(registry) {
+const enableBackingStoreForSerializationRegistry = (registry) => {
     for (const [k, v] of registry.contentTypeAssociatedFactories) {
         if (!(v instanceof BackingStoreSerializationWriterProxyFactory || v instanceof SerializationWriterFactoryRegistry)) {
             registry.contentTypeAssociatedFactories.set(k, new BackingStoreSerializationWriterProxyFactory(v));
         }
     }
-}
+};
 
 /*
  * Copyright The OpenTelemetry Authors
@@ -2635,9 +2635,9 @@ class DateOnly {
  * @param digits The number of digits to pad
  * @returns The formatted segment
  */
-function formatSegment(segment, digits = 2) {
+const formatSegment = (segment, digits = 2) => {
     return segment.toString().padStart(digits, "0");
-}
+};
 
 var dist = {};
 
@@ -2868,7 +2868,7 @@ class Duration {
  * @param canon The function that canonicalizes the property name.
  * @returns A new object that can be used as a dictionary with case-insensitive keys.
  */
-function dictionaryWithCanonicalKeys(canon) {
+const dictionaryWithCanonicalKeys = (canon) => {
     const keysNormalizationMap = new Map();
     return new Proxy({}, {
         /**
@@ -2877,7 +2877,7 @@ function dictionaryWithCanonicalKeys(canon) {
          * @param prop The property to get.
          * @returns The value of the property.
          */
-        get(target, prop) {
+        get: (target, prop) => {
             const normalKey = canon(prop);
             return Reflect.get(target, normalKey);
         },
@@ -2888,7 +2888,7 @@ function dictionaryWithCanonicalKeys(canon) {
          * @param value The value to set.
          * @returns A boolean indicating whether the property was set.
          */
-        set(target, prop, value) {
+        set: (target, prop, value) => {
             const nonNormalKey = prop.toString();
             const normalKey = canon(prop);
             keysNormalizationMap.set(normalKey, nonNormalKey);
@@ -2900,7 +2900,7 @@ function dictionaryWithCanonicalKeys(canon) {
          * @param prop The property to check.
          * @returns A boolean indicating whether the property exists.
          */
-        has(_, prop) {
+        has: (_, prop) => {
             const normalKey = canon(prop);
             return keysNormalizationMap.has(normalKey);
         },
@@ -2911,7 +2911,7 @@ function dictionaryWithCanonicalKeys(canon) {
          * @param attribs The attributes of the property.
          * @returns A boolean indicating whether the property was defined.
          */
-        defineProperty(target, prop, attribs) {
+        defineProperty: (target, prop, attribs) => {
             const nonNormalKey = prop.toString();
             const normalKey = canon(prop);
             keysNormalizationMap.set(normalKey, nonNormalKey);
@@ -2923,7 +2923,7 @@ function dictionaryWithCanonicalKeys(canon) {
          * @param prop The property to delete.
          * @returns A boolean indicating whether the property was deleted.
          */
-        deleteProperty(target, prop) {
+        deleteProperty: (target, prop) => {
             const normalKey = canon(prop);
             keysNormalizationMap.delete(normalKey);
             return Reflect.deleteProperty(target, normalKey);
@@ -2934,19 +2934,19 @@ function dictionaryWithCanonicalKeys(canon) {
          * @param prop The property to gets its descriptor.
          * @returns The property descriptor.
          */
-        getOwnPropertyDescriptor(target, prop) {
+        getOwnPropertyDescriptor: (target, prop) => {
             return Reflect.getOwnPropertyDescriptor(target, canon(prop));
         },
-        ownKeys() {
+        ownKeys: () => {
             return [...keysNormalizationMap.values()];
         },
     });
-}
+};
 /**
  * A wrapper for type Record that creates a Record with case insensitive keys
  * @returns A new object that can be used as a dictionary with case-insensitive keys.
  */
-function createRecordWithCaseInsensitiveKeys() {
+const createRecordWithCaseInsensitiveKeys = () => {
     /**
      * A function that takes a property name and returns its canonical form.
      * @param prop The property name to be canonicalized.
@@ -2954,7 +2954,7 @@ function createRecordWithCaseInsensitiveKeys() {
      */
     const record = dictionaryWithCanonicalKeys((p) => (typeof p === "string" ? p.toLowerCase() : p.toString().toLowerCase()));
     return record;
-}
+};
 
 /**
  * -------------------------------------------------------------------------------------------
@@ -3054,6 +3054,7 @@ class Headers extends Map {
      * @param callbackfn A function that accepts up to three arguments. forEach calls the callbackfn function one time for each header in the dictionary.
      * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
      */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     forEach(callbackfn, thisArg) {
         for (const header in this.headers) {
             if (Object.prototype.hasOwnProperty.call(this.headers, header)) {
@@ -3335,10 +3336,10 @@ const serializeMultipartBody = (writer, multipartBody = new MultipartBody()) =>
                 writer.writeStringValue(undefined, part.content);
             }
             else if (part.content instanceof ArrayBuffer) {
-                writer.writeByteArrayValue(undefined, new Uint8Array(part.content));
+                writer.writeByteArrayValue(undefined, new Uint8Array(part.content).buffer);
             }
             else if (part.content instanceof Uint8Array) {
-                writer.writeByteArrayValue(undefined, part.content);
+                writer.writeByteArrayValue(undefined, part.content.buffer);
             }
             else if (part.serializationCallback) {
                 if (!multipartBody.requestAdapter) {
@@ -3354,7 +3355,7 @@ const serializeMultipartBody = (writer, multipartBody = new MultipartBody()) =>
                 }
                 partSerializationWriter.writeObjectValue(undefined, part.content, part.serializationCallback);
                 const partContent = partSerializationWriter.getSerializedContent();
-                writer.writeByteArrayValue(undefined, new Uint8Array(partContent));
+                writer.writeByteArrayValue(undefined, new Uint8Array(partContent).buffer);
             }
             else {
                 throw new Error("unsupported content type for multipart body: " + typeof part.content);
@@ -4018,6 +4019,10 @@ const apiClientProxifier = (requestAdapter, pathParameters, navigationMetadata,
                         return apiClientProxifier(requestAdapter, downWardPathParameters, navigationCandidate.navigationMetadata, navigationCandidate.requestsMetadata);
                     };
                 }
+                if (name === "then") {
+                    // handle returning proxy from an async method
+                    return undefined;
+                }
                 throw new Error(`couldn't find navigation property ${name} data: ${JSON.stringify(navigationMetadata)}`);
             }
         },
@@ -4055,7 +4060,7 @@ class AllowedHostsValidator {
      */
     constructor(allowedHosts = new Set()) {
         this.validateHosts(allowedHosts);
-        this.allowedHosts = allowedHosts !== null && allowedHosts !== void 0 ? allowedHosts : new Set();
+        this.allowedHosts = this.normalizeHosts(allowedHosts);
     }
     /**
      * Gets the list of valid hosts.  If the list is empty, all hosts are valid.
@@ -4070,7 +4075,7 @@ class AllowedHostsValidator {
      */
     setAllowedHosts(allowedHosts) {
         this.validateHosts(allowedHosts);
-        this.allowedHosts = allowedHosts;
+        this.allowedHosts = this.normalizeHosts(allowedHosts);
     }
     /**
      * Checks whether the provided host is valid.
@@ -4078,7 +4083,7 @@ class AllowedHostsValidator {
      * @returns True if the host is valid, false otherwise.
      */
     isUrlHostValid(url) {
-        var _a, _b;
+        var _a;
         if (!url)
             return false;
         if (this.allowedHosts.size === 0)
@@ -4095,7 +4100,7 @@ class AllowedHostsValidator {
             return this.isHostAndPathValid(url);
         }
         if ((_a = window === null || window === void 0 ? void 0 : window.location) === null || _a === void 0 ? void 0 : _a.host) {
-            return this.allowedHosts.has((_b = window.location.host) === null || _b === void 0 ? void 0 : _b.toLowerCase());
+            return this.isHostValid(window.location.host);
         }
         return false;
     }
@@ -4104,11 +4109,21 @@ class AllowedHostsValidator {
         if (hostAndRest.length >= 2) {
             const host = hostAndRest[0];
             if (host) {
-                return this.allowedHosts.has(host.toLowerCase());
+                return this.isHostValid(host.split(":")[0]);
             }
         }
         return false;
     }
+    isHostValid(host) {
+        const normalizedHost = host.toLowerCase();
+        if (this.allowedHosts.has(normalizedHost)) {
+            return true;
+        }
+        return Array.from(this.allowedHosts).some((allowedHost) => allowedHost.startsWith(".") && normalizedHost.endsWith(allowedHost));
+    }
+    normalizeHosts(hostsToNormalize) {
+        return new Set(Array.from(hostsToNormalize, (host) => host.toLowerCase()));
+    }
     validateHosts(hostsToValidate) {
         if (!hostsToValidate) {
             throw new Error("hostsToValidate cannot be null");
@@ -4132,27 +4147,27 @@ const localhostStrings = new Set(["localhost", "[::1]", "::1", "127.0.0.1"]);
  * Validates the protocol of the url.
  * @param url - The url to validate.
  */
-function validateProtocol(url) {
+const validateProtocol = (url) => {
     if (!isLocalhostUrl(url) && !url.toLocaleLowerCase().startsWith("https://") && !windowUrlStartsWithHttps()) {
         throw new Error("Authentication scheme can only be used with https requests");
     }
-}
+};
 /**
  * Checks if the window url starts with https.
  * @returns True if the window url starts with https, false otherwise.
  */
-function windowUrlStartsWithHttps() {
+const windowUrlStartsWithHttps = () => {
     if (!inNodeEnv()) {
         return window.location.protocol.toLocaleLowerCase() === "https:";
     }
     return false;
-}
+};
 /**
  * Checks if the url is a localhost url.
  * @param urlString - The url to check.
  * @returns True if the url is a localhost url, false otherwise.
  */
-function isLocalhostUrl(urlString) {
+const isLocalhostUrl = (urlString) => {
     try {
         const url = new URL(urlString);
         return localhostStrings.has(url.hostname);
@@ -4160,7 +4175,7 @@ function isLocalhostUrl(urlString) {
     catch (_a) {
         return false;
     }
-}
+};
 
 /** Authenticate a request by using an API Key */
 class ApiKeyAuthenticationProvider {
@@ -4285,14 +4300,9 @@ class HttpClient {
         middlewares = (middlewares === null || middlewares === void 0 ? void 0 : middlewares.length) && middlewares[0] ? middlewares : MiddlewareFactory.getDefaultMiddlewares(customFetch);
         // If a custom fetch function is provided, add a CustomFetchHandler to the end of the middleware chain
         if (this.customFetch) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-            middlewares.push(new CustomFetchHandler(customFetch));
-        }
-        // eslint-disable-next-line no-console
-        console.debug("Registered middlewares: " + middlewares.map((m) => m.constructor.name).join(", "));
-        // eslint-disable-next-line no-console
-        console.debug("Hint: To improve performance, use MiddlewareFactory.getPerformanceMiddlewares(customFetch) instead of MiddlewareFactory.getDefaultMiddlewares(customFetch)");
-        // Set the middleware chain
+            middlewares.push(new CustomFetchHandler(this.customFetch));
+        }
+        // Set the middleware handlers chain
         this.setMiddleware(...middlewares);
     }
     /**
@@ -4347,7 +4357,7 @@ class ObservabilityOptionsImpl {
  * @param requestOptions The request options
  * @returns The observability options
  */
-function getObservabilityOptionsFromRequest(requestOptions) {
+const getObservabilityOptionsFromRequest = (requestOptions) => {
     if (requestOptions) {
         const observabilityOptions = requestOptions[ObservabilityOptionKey];
         if (observabilityOptions instanceof ObservabilityOptionsImpl) {
@@ -4355,7 +4365,7 @@ function getObservabilityOptionsFromRequest(requestOptions) {
         }
     }
     return undefined;
-}
+};
 
 /**
  * -------------------------------------------------------------------------------------------
@@ -4430,31 +4440,34 @@ class FetchRequestAdapter {
                             case "number":
                             case "boolean":
                             case "Date":
+                            case "Duration":
+                            case "DateOnly":
+                            case "TimeOnly":
                                 // eslint-disable-next-line no-case-declarations
                                 const rootNode = await this.getRootParseNode(response);
                                 return trace.getTracer(this.observabilityOptions.getTracerInstrumentationName()).startActiveSpan(`getCollectionOf${responseType}Value`, (deserializeSpan) => {
                                     try {
                                         span.setAttribute(FetchRequestAdapter.responseTypeAttributeKey, responseType);
                                         if (responseType === "string") {
-                                            return rootNode.getCollectionOfPrimitiveValues();
+                                            return rootNode.getCollectionOfPrimitiveValues(responseType);
                                         }
                                         else if (responseType === "number") {
-                                            return rootNode.getCollectionOfPrimitiveValues();
+                                            return rootNode.getCollectionOfPrimitiveValues(responseType);
                                         }
                                         else if (responseType === "boolean") {
-                                            return rootNode.getCollectionOfPrimitiveValues();
+                                            return rootNode.getCollectionOfPrimitiveValues(responseType);
                                         }
                                         else if (responseType === "Date") {
-                                            return rootNode.getCollectionOfPrimitiveValues();
+                                            return rootNode.getCollectionOfPrimitiveValues(responseType);
                                         }
                                         else if (responseType === "Duration") {
-                                            return rootNode.getCollectionOfPrimitiveValues();
+                                            return rootNode.getCollectionOfPrimitiveValues(responseType);
                                         }
                                         else if (responseType === "DateOnly") {
-                                            return rootNode.getCollectionOfPrimitiveValues();
+                                            return rootNode.getCollectionOfPrimitiveValues(responseType);
                                         }
                                         else if (responseType === "TimeOnly") {
-                                            return rootNode.getCollectionOfPrimitiveValues();
+                                            return rootNode.getCollectionOfPrimitiveValues(responseType);
                                         }
                                         else {
                                             throw new Error("unexpected type to deserialize");
@@ -4985,7 +4998,7 @@ FetchRequestAdapter.authenticateChallengedEventKey = "com.microsoft.kiota.authen
  * @returns A header value for the given key from the request
  */
 const getRequestHeader = (options, key) => {
-    if (options && options.headers) {
+    if (options === null || options === void 0 ? void 0 : options.headers) {
         return options.headers[key];
     }
     return undefined;
@@ -5206,7 +5219,7 @@ class CompressionHandler {
         }
         const uint8ArrayToStream = (uint8Array) => {
             return new ReadableStream({
-                start(controller) {
+                start: (controller) => {
                     controller.enqueue(uint8Array);
                     controller.close();
                 },
@@ -5463,6 +5476,47 @@ class ParametersNameDecodingHandler {
  * -------------------------------------------------------------------------------------------
  */
 const RedirectHandlerOptionKey = "RedirectHandlerOption";
+/**
+ * The default implementation for scrubbing sensitive headers during redirects.
+ * This function removes Authorization, Cookie, and Proxy-Authorization headers when the host or scheme changes.
+ *
+ * It is exported so that consumers providing a custom {@link ScrubSensitiveHeaders} callback can call it to
+ * retain the default behavior and then layer additional logic on top (e.g. removing custom headers such as
+ * `X-Api-Key`), matching the composable pattern available in the .NET and Python Kiota SDKs.
+ *
+ * Note: In browser environments, `Proxy-Authorization` is a forbidden header name and typically cannot be set;
+ * it is still removed here if present (e.g. in Node.js or other non-browser runtimes).
+ * @param headers - The headers object to modify
+ * @param originalUrl - The original request URL
+ * @param newUrl - The new redirect URL
+ */
+const defaultScrubSensitiveHeaders = (headers, originalUrl, newUrl) => {
+    if (!headers || !originalUrl || !newUrl) {
+        return;
+    }
+    try {
+        const originalUri = new URL(originalUrl);
+        const newUri = new URL(newUrl);
+        // Remove Authorization, Cookie, and Proxy-Authorization headers if the request's scheme or host changes.
+        // Header keys must be matched case-insensitively because FetchRequestAdapter.getRequestFromRequestInformation
+        // lower-cases every header key before the headers object reaches this middleware, so PascalCase
+        // property deletes such as `delete headers.Authorization` would otherwise be a no-op.
+        const isDifferentHostOrScheme = originalUri.host.toLowerCase() !== newUri.host.toLowerCase() || originalUri.protocol.toLowerCase() !== newUri.protocol.toLowerCase();
+        if (isDifferentHostOrScheme) {
+            for (const key of Object.keys(headers)) {
+                const lower = key.toLowerCase();
+                if (lower === "authorization" || lower === "cookie" || lower === "proxy-authorization") {
+                    delete headers[key];
+                }
+            }
+        }
+    }
+    catch (_a) {
+        // If URL parsing fails, don't modify headers
+        // This handles cases where invalid URLs are passed
+        return;
+    }
+};
 /**
  * MiddlewareOptions
  * A class representing RedirectHandlerOptions
@@ -5477,7 +5531,7 @@ class RedirectHandlerOptions {
      * @example	const options = new RedirectHandlerOptions({ maxRedirects: 5 });
      */
     constructor(options = {}) {
-        var _a, _b;
+        var _a, _b, _c;
         if (options.maxRedirects && options.maxRedirects > RedirectHandlerOptions.MAX_MAX_REDIRECTS) {
             const error = new Error(`MaxRedirects should not be more than ${RedirectHandlerOptions.MAX_MAX_REDIRECTS}`);
             error.name = "MaxLimitExceeded";
@@ -5490,6 +5544,7 @@ class RedirectHandlerOptions {
         }
         this.maxRedirects = (_a = options.maxRedirects) !== null && _a !== void 0 ? _a : RedirectHandlerOptions.DEFAULT_MAX_REDIRECTS;
         this.shouldRedirect = (_b = options.shouldRedirect) !== null && _b !== void 0 ? _b : RedirectHandlerOptions.defaultShouldRetry;
+        this.scrubSensitiveHeaders = (_c = options.scrubSensitiveHeaders) !== null && _c !== void 0 ? _c : RedirectHandlerOptions.defaultScrubSensitiveHeaders;
     }
     getKey() {
         return RedirectHandlerOptionKey;
@@ -5509,6 +5564,11 @@ RedirectHandlerOptions.MAX_MAX_REDIRECTS = 20;
  * @returns true
  */
 RedirectHandlerOptions.defaultShouldRetry = () => true;
+/**
+ * The default {@link ScrubSensitiveHeaders} callback used when none is supplied.
+ * Delegates to the exported {@link defaultScrubSensitiveHeaders} function.
+ */
+RedirectHandlerOptions.defaultScrubSensitiveHeaders = defaultScrubSensitiveHeaders;
 
 /**
  * -------------------------------------------------------------------------------------------
@@ -5575,27 +5635,6 @@ class RedirectHandler {
     isRelativeURL(url) {
         return !url.includes("://");
     }
-    /**
-     *
-     * To check whether the authorization header in the request should be dropped for consequent redirected requests
-     * @param requestUrl - The request url value
-     * @param redirectUrl - The redirect url value
-     * @returns A boolean representing whether the authorization header in the request should be dropped for consequent redirected requests
-     */
-    shouldDropAuthorizationHeader(requestUrl, redirectUrl) {
-        const schemeHostRegex = /^[A-Za-z].+?:\/\/.+?(?=\/|$)/;
-        const requestMatches = schemeHostRegex.exec(requestUrl);
-        let requestAuthority;
-        let redirectAuthority;
-        if (requestMatches !== null) {
-            requestAuthority = requestMatches[0];
-        }
-        const redirectMatches = schemeHostRegex.exec(redirectUrl);
-        if (redirectMatches !== null) {
-            redirectAuthority = redirectMatches[0];
-        }
-        return typeof requestAuthority !== "undefined" && typeof redirectAuthority !== "undefined" && requestAuthority !== redirectAuthority;
-    }
     /**
      * To execute the next middleware and to handle in case of redirect response returned by the server
      * @param url - The url string value
@@ -5614,19 +5653,22 @@ class RedirectHandler {
         }
         if (redirectCount < currentOptions.maxRedirects && this.isRedirect(response) && this.hasLocationHeader(response) && currentOptions.shouldRedirect(response)) {
             ++redirectCount;
+            const redirectUrl = this.getLocationHeader(response);
+            if (!redirectUrl) {
+                return response;
+            }
+            // Resolve relative URLs
+            const newUrl = this.isRelativeURL(redirectUrl) ? new URL(redirectUrl, url).toString() : redirectUrl;
+            // Scrub sensitive headers before following the redirect
+            if (fetchRequestInit.headers) {
+                currentOptions.scrubSensitiveHeaders(fetchRequestInit.headers, url, newUrl);
+            }
+            // Handle 303 See Other: change POST to GET
             if (response.status === RedirectHandler.STATUS_CODE_SEE_OTHER) {
                 fetchRequestInit.method = HttpMethod.GET;
                 delete fetchRequestInit.body;
             }
-            else {
-                const redirectUrl = this.getLocationHeader(response);
-                if (redirectUrl) {
-                    if (fetchRequestInit.headers && !this.isRelativeURL(redirectUrl) && this.shouldDropAuthorizationHeader(url, redirectUrl)) {
-                        delete fetchRequestInit.headers[RedirectHandler.AUTHORIZATION_HEADER];
-                    }
-                    url = redirectUrl;
-                }
-            }
+            url = newUrl;
             if (tracerName) {
                 return trace.getTracer(tracerName).startActiveSpan(`redirectHandler - redirect ${redirectCount}`, (span) => {
                     try {
@@ -5692,10 +5734,6 @@ RedirectHandler.STATUS_CODE_SEE_OTHER = 303;
  * A member holding the name of the location header
  */
 RedirectHandler.LOCATION_HEADER = "Location";
-/**
- * A member representing the authorization header name
- */
-RedirectHandler.AUTHORIZATION_HEADER = "Authorization";
 /**
  * A member holding the manual redirect value
  */
@@ -6192,7 +6230,6 @@ class MiddlewareFactory {
      * Returns the default middleware chain an array with the  middleware handlers
      * @returns an array of the middleware handlers of the default middleware chain
      */
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
     static getDefaultMiddlewares(customFetch = (...args) => fetch(...args)) {
         return [new RetryHandler(), new RedirectHandler(), new ParametersNameDecodingHandler(), new UserAgentHandler(), new HeadersInspectionHandler(), new UrlReplaceHandler(), new CustomFetchHandler(customFetch)];
     }
@@ -6201,7 +6238,6 @@ class MiddlewareFactory {
      * Returns the default middleware chain + performance middleware
      * @returns an array of the middleware handlers of the default + performance middleware chain
      */
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
     static getPerformanceMiddlewares(customFetch = (...args) => fetch(...args)) {
         const middlewares = MiddlewareFactory.getDefaultMiddlewares(customFetch);
         middlewares.splice(middlewares.length - 3, 0, new CompressionHandler()); // insert CompressionHandler before HeadersInspectionHandler
@@ -12316,7 +12352,7 @@ function deserializeIntoGetPlanListSchema_data_tierTag(getPlanListSchema_data_ti
 // @ts-ignore
 function deserializeIntoGetPlanListSchema_filterOptions(getPlanListSchema_filterOptions = {}) {
     return {
-        "currencies": n => { getPlanListSchema_filterOptions.currencies = n.getCollectionOfPrimitiveValues(); },
+        "currencies": n => { getPlanListSchema_filterOptions.currencies = n.getCollectionOfPrimitiveValues("string"); },
         "intervals": n => { getPlanListSchema_filterOptions.intervals = n.getCollectionOfObjectValues(createGetPlanListSchema_filterOptions_intervalsFromDiscriminatorValue); },
     };
 }
@@ -13165,7 +13201,7 @@ function deserializeIntoGetSubscriptionInvoicesSchema_data_lines_data_parent_sub
 function deserializeIntoGetSubscriptionInvoicesSchema_data_lines_data_parent_subscription_item_details_proration_details_credited_items(getSubscriptionInvoicesSchema_data_lines_data_parent_subscription_item_details_proration_details_credited_items = {}) {
     return {
         "invoice": n => { getSubscriptionInvoicesSchema_data_lines_data_parent_subscription_item_details_proration_details_credited_items.invoice = n.getStringValue(); },
-        "invoice_line_items": n => { getSubscriptionInvoicesSchema_data_lines_data_parent_subscription_item_details_proration_details_credited_items.invoiceLineItems = n.getCollectionOfPrimitiveValues(); },
+        "invoice_line_items": n => { getSubscriptionInvoicesSchema_data_lines_data_parent_subscription_item_details_proration_details_credited_items.invoiceLineItems = n.getCollectionOfPrimitiveValues("string"); },
     };
 }
 /**
@@ -13318,7 +13354,7 @@ function deserializeIntoGetSubscriptionInvoicesSchema_data_lines_data_proration_
 function deserializeIntoGetSubscriptionInvoicesSchema_data_lines_data_proration_details_credited_items(getSubscriptionInvoicesSchema_data_lines_data_proration_details_credited_items = {}) {
     return {
         "invoice": n => { getSubscriptionInvoicesSchema_data_lines_data_proration_details_credited_items.invoice = n.getStringValue(); },
-        "invoice_line_items": n => { getSubscriptionInvoicesSchema_data_lines_data_proration_details_credited_items.invoiceLineItems = n.getCollectionOfPrimitiveValues(); },
+        "invoice_line_items": n => { getSubscriptionInvoicesSchema_data_lines_data_proration_details_credited_items.invoiceLineItems = n.getCollectionOfPrimitiveValues("string"); },
     };
 }
 /**
@@ -20001,58 +20037,40 @@ class FormParseNode {
         this._rawString = _rawString;
         this.backingStoreFactory = backingStoreFactory;
         this._fields = {};
-        this.normalizeKey = (key) => decodeURIComponent(key).trim();
-        this.getStringValue = () => decodeURIComponent(this._rawString);
+        this.getStringValue = () => this.getStringValueFromRaw(this._rawString);
         this.getChildNode = (identifier) => {
             if (this._fields[identifier]) {
                 return new FormParseNode(this._fields[identifier], this.backingStoreFactory);
             }
             return undefined;
         };
-        this.getBooleanValue = () => {
-            var _a;
-            const value = (_a = this.getStringValue()) === null || _a === void 0 ? void 0 : _a.toLowerCase();
-            if (value === "true" || value === "1") {
-                return true;
-            }
-            else if (value === "false" || value === "0") {
-                return false;
-            }
-            return undefined;
-        };
-        this.getNumberValue = () => parseFloat(this.getStringValue());
-        this.getGuidValue = () => parseGuidString(this.getStringValue());
-        this.getDateValue = () => new Date(Date.parse(this.getStringValue()));
-        this.getDateOnlyValue = () => DateOnly.parse(this.getStringValue());
-        this.getTimeOnlyValue = () => TimeOnly.parse(this.getStringValue());
-        this.getDurationValue = () => Duration.parse(this.getStringValue());
-        this.getCollectionOfPrimitiveValues = () => {
-            return this._rawString.split(",").map((x) => {
-                const currentParseNode = new FormParseNode(x, this.backingStoreFactory);
-                const typeOfX = typeof x;
-                if (typeOfX === "boolean") {
-                    return currentParseNode.getBooleanValue();
-                }
-                else if (typeOfX === "string") {
-                    return currentParseNode.getStringValue();
-                }
-                else if (typeOfX === "number") {
-                    return currentParseNode.getNumberValue();
-                }
-                else if (x instanceof Date) {
-                    return currentParseNode.getDateValue();
-                }
-                else if (x instanceof DateOnly) {
-                    return currentParseNode.getDateValue();
-                }
-                else if (x instanceof TimeOnly) {
-                    return currentParseNode.getDateValue();
-                }
-                else if (x instanceof Duration) {
-                    return currentParseNode.getDateValue();
-                }
-                else {
-                    throw new Error(`encountered an unknown type during deserialization ${typeof x}`);
+        this.getBooleanValue = () => this.getBooleanValueFromRaw(this._rawString);
+        this.getNumberValue = () => this.getNumberValueFromRaw(this._rawString);
+        this.getGuidValue = () => this.getGuidValueFromRaw(this._rawString);
+        this.getDateValue = () => this.getDateValueFromRaw(this._rawString);
+        this.getDateOnlyValue = () => this.getDateOnlyValueFromRaw(this._rawString);
+        this.getTimeOnlyValue = () => this.getTimeOnlyValueFromRaw(this._rawString);
+        this.getDurationValue = () => this.getDurationValueFromRaw(this._rawString);
+        this.getCollectionOfPrimitiveValues = (primitiveType) => {
+            const values = this._rawString.split(",");
+            return values.map((x) => {
+                switch (primitiveType) {
+                    case "boolean":
+                        return this.getBooleanValueFromRaw(x);
+                    case "number":
+                        return this.getNumberValueFromRaw(x);
+                    case "Date":
+                        return this.getDateValueFromRaw(x);
+                    case "DateOnly":
+                        return this.getDateOnlyValueFromRaw(x);
+                    case "TimeOnly":
+                        return this.getTimeOnlyValueFromRaw(x);
+                    case "Duration":
+                        return this.getDurationValueFromRaw(x);
+                    case "string":
+                        return this.getStringValueFromRaw(x);
+                    default:
+                        throw new Error(`encountered an unsupported type during deserialization ${primitiveType}`);
                 }
             });
         };
@@ -20079,7 +20097,6 @@ class FormParseNode {
             if (!rawValues) {
                 return [];
             }
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
             return rawValues.split(",").map((x) => getEnumValueFromStringValue(x, type));
         };
         this.getEnumValue = (type) => {
@@ -20089,20 +20106,6 @@ class FormParseNode {
             }
             return getEnumValueFromStringValue(rawValue, type);
         };
-        this.assignFieldValues = (model, parsableFactory) => {
-            const fields = parsableFactory(this)(model);
-            Object.entries(this._fields)
-                .filter((x) => !/^null$/i.test(x[1]))
-                .forEach(([k, v]) => {
-                const deserializer = fields[k];
-                if (deserializer) {
-                    deserializer(new FormParseNode(v, this.backingStoreFactory));
-                }
-                else {
-                    model[k] = v;
-                }
-            });
-        };
         if (!_rawString) {
             throw new Error("rawString cannot be undefined");
         }
@@ -20120,9 +20123,57 @@ class FormParseNode {
             }
         });
     }
+    normalizeKey(key) {
+        return decodeURIComponent(key).trim();
+    }
+    getStringValueFromRaw(value) {
+        return decodeURIComponent(value);
+    }
+    getBooleanValueFromRaw(value) {
+        const decoded = this.getStringValueFromRaw(value).toLowerCase();
+        if (decoded === "true" || decoded === "1") {
+            return true;
+        }
+        else if (decoded === "false" || decoded === "0") {
+            return false;
+        }
+        return undefined;
+    }
+    getNumberValueFromRaw(value) {
+        return parseFloat(this.getStringValueFromRaw(value));
+    }
+    getGuidValueFromRaw(value) {
+        return parseGuidString(this.getStringValueFromRaw(value));
+    }
+    getDateValueFromRaw(value) {
+        return new Date(Date.parse(this.getStringValueFromRaw(value)));
+    }
+    getDateOnlyValueFromRaw(value) {
+        return DateOnly.parse(this.getStringValueFromRaw(value));
+    }
+    getTimeOnlyValueFromRaw(value) {
+        return TimeOnly.parse(this.getStringValueFromRaw(value));
+    }
+    getDurationValueFromRaw(value) {
+        return Duration.parse(this.getStringValueFromRaw(value));
+    }
     getByteArrayValue() {
         throw new Error("serialization of byt arrays is not supported with URI encoding");
     }
+    assignFieldValues(model, parsableFactory) {
+        const fields = parsableFactory(this)(model);
+        Object.entries(this._fields)
+            .filter((x) => !/^null$/i.test(x[1]))
+            .forEach(([k, v]) => {
+            const deserializer = fields[k];
+            if (deserializer) {
+                deserializer(new FormParseNode(v, this.backingStoreFactory));
+            }
+            else {
+                model[k] = v;
+            }
+        });
+    }
 }
 
 /**
@@ -20205,6 +20256,7 @@ class FormSerializationWriter {
             throw new Error(`serialization of collections is not supported with URI encoding`);
         };
         this.writeObjectValue = (key, value, serializerMethod) => {
+            var _a, _b, _c;
             if (++this.depth > 0) {
                 throw new Error(`serialization of nested objects is not supported with URI encoding`);
             }
@@ -20215,10 +20267,10 @@ class FormSerializationWriter {
                 if (key) {
                     this.writePropertyName(key);
                 }
-                this.onBeforeObjectSerialization && this.onBeforeObjectSerialization(value);
-                this.onStartObjectSerialization && this.onStartObjectSerialization(value, this);
+                (_a = this.onBeforeObjectSerialization) === null || _a === void 0 ? void 0 : _a.call(this, value);
+                (_b = this.onStartObjectSerialization) === null || _b === void 0 ? void 0 : _b.call(this, value, this);
                 serializerMethod(this, value);
-                this.onAfterObjectSerialization && this.onAfterObjectSerialization(value);
+                (_c = this.onAfterObjectSerialization) === null || _c === void 0 ? void 0 : _c.call(this, value);
                 if (this.writer.length > 0 && this.writer[this.writer.length - 1] === FormSerializationWriter.propertySeparator) {
                     // removing the last separator
                     this.writer.pop();
@@ -20377,47 +20429,52 @@ class JsonParseNode {
     constructor(_jsonNode, backingStoreFactory) {
         this._jsonNode = _jsonNode;
         this.backingStoreFactory = backingStoreFactory;
-        this.getStringValue = () => (typeof this._jsonNode === "string" ? this._jsonNode : undefined);
+        this.getStringValue = () => this.getStringValueFromRaw(this._jsonNode);
         this.getChildNode = (identifier) => (this._jsonNode && typeof this._jsonNode === "object" && this._jsonNode[identifier] !== undefined ? new JsonParseNode(this._jsonNode[identifier], this.backingStoreFactory) : undefined);
         this.getBooleanValue = () => (typeof this._jsonNode === "boolean" ? this._jsonNode : undefined);
         this.getNumberValue = () => (typeof this._jsonNode === "number" ? this._jsonNode : undefined);
-        this.getGuidValue = () => parseGuidString(this.getStringValue());
-        this.getDateValue = () => (this._jsonNode ? new Date(this._jsonNode) : undefined);
-        this.getDateOnlyValue = () => DateOnly.parse(this.getStringValue());
-        this.getTimeOnlyValue = () => TimeOnly.parse(this.getStringValue());
-        this.getDurationValue = () => Duration.parse(this.getStringValue());
-        this.getCollectionOfPrimitiveValues = () => {
+        this.getGuidValue = () => this.getGuidValueFromRaw(this._jsonNode);
+        this.getDateValue = () => this.getDateValueFromRaw(this._jsonNode);
+        this.getDateOnlyValue = () => this.getDateOnlyValueFromRaw(this._jsonNode);
+        this.getTimeOnlyValue = () => this.getTimeOnlyValueFromRaw(this._jsonNode);
+        this.getDurationValue = () => this.getDurationValueFromRaw(this._jsonNode);
+        this.getCollectionOfPrimitiveValues = (primitiveType) => {
             if (!Array.isArray(this._jsonNode)) {
                 return undefined;
             }
-            return this._jsonNode.map((x) => {
-                const currentParseNode = new JsonParseNode(x, this.backingStoreFactory);
-                const typeOfX = typeof x;
-                if (typeOfX === "boolean") {
-                    return currentParseNode.getBooleanValue();
-                }
-                else if (typeOfX === "string") {
-                    return currentParseNode.getStringValue();
-                }
-                else if (typeOfX === "number") {
-                    return currentParseNode.getNumberValue();
-                }
-                else if (x instanceof Date) {
-                    return currentParseNode.getDateValue();
-                }
-                else if (x instanceof DateOnly) {
-                    return currentParseNode.getDateValue();
-                }
-                else if (x instanceof TimeOnly) {
-                    return currentParseNode.getDateValue();
-                }
-                else if (x instanceof Duration) {
-                    return currentParseNode.getDateValue();
-                }
-                else {
-                    throw new Error(`encountered an unknown type during deserialization ${typeof x}`);
-                }
-            });
+            return this._jsonNode.map((x) => this.getPrimitiveValue(x, primitiveType));
+        };
+        this.getPrimitiveValue = (value, primitiveType) => {
+            if (value === null) {
+                return null;
+            }
+            switch (primitiveType) {
+                case "boolean":
+                    if (typeof value !== "boolean") {
+                        throw new Error(`encountered an unsupported type during deserialization ${typeof value}`);
+                    }
+                    return value;
+                case "number":
+                    if (typeof value !== "number") {
+                        throw new Error(`encountered an unsupported type during deserialization ${typeof value}`);
+                    }
+                    return value;
+                case "Date":
+                    return this.getDateValueFromRaw(value);
+                case "DateOnly":
+                    return this.getDateOnlyValueFromRaw(value);
+                case "TimeOnly":
+                    return this.getTimeOnlyValueFromRaw(value);
+                case "Duration":
+                    return this.getDurationValueFromRaw(value);
+                case "string":
+                    if (typeof value !== "string") {
+                        throw new Error(`encountered an unsupported type during deserialization ${typeof value}`);
+                    }
+                    return value;
+                default:
+                    throw new Error(`encountered an unsupported type during deserialization ${primitiveType}`);
+            }
         };
         this.getCollectionOfObjectValues = (method) => {
             if (!Array.isArray(this._jsonNode)) {
@@ -20492,10 +20549,12 @@ class JsonParseNode {
             if (Array.isArray(this._jsonNode)) {
                 return this._jsonNode
                     .map((x) => {
-                    const node = new JsonParseNode(x, this.backingStoreFactory);
-                    return node.getEnumValue(type);
+                    if (typeof x === "string") {
+                        return getEnumValueFromStringValue(x, type);
+                    }
+                    return undefined;
                 })
-                    .filter(Boolean);
+                    .filter((value) => value !== undefined);
             }
             return [];
         };
@@ -20507,6 +20566,33 @@ class JsonParseNode {
             return getEnumValueFromStringValue(rawValue, type);
         };
     }
+    getStringValueFromRaw(value) {
+        return typeof value === "string" ? value : undefined;
+    }
+    getGuidValueFromRaw(value) {
+        return parseGuidString(this.getStringValueFromRaw(value));
+    }
+    getDateValueFromRaw(value) {
+        if (value instanceof Date) {
+            return new Date(value.getTime());
+        }
+        if (typeof value === "number") {
+            return new Date(value);
+        }
+        if (typeof value === "string") {
+            return new Date(value);
+        }
+        return undefined;
+    }
+    getDateOnlyValueFromRaw(value) {
+        return value instanceof DateOnly ? value : DateOnly.parse(this.getStringValueFromRaw(value));
+    }
+    getTimeOnlyValueFromRaw(value) {
+        return value instanceof TimeOnly ? value : TimeOnly.parse(this.getStringValueFromRaw(value));
+    }
+    getDurationValueFromRaw(value) {
+        return value instanceof Duration ? value : Duration.parse(this.getStringValueFromRaw(value));
+    }
     getByteArrayValue() {
         const strValue = this.getStringValue();
         if (strValue && strValue.length > 0) {
@@ -20522,7 +20608,7 @@ class JsonParseNode {
              * TODO: Consider standardizing on a cross-platform UInt8Array.fromBase64 (after the API is stabilized across browsers)
              * in the future instead of the current environment-specific approach
              */
-            return inNodeEnv() ? new Uint8Array(Buffer.from(strValue, "base64")).buffer : new TextEncoder().encode(strValue);
+            return inNodeEnv() ? new Uint8Array(Buffer.from(strValue, "base64")).buffer : new TextEncoder().encode(strValue).buffer;
         }
         return undefined;
     }
@@ -20584,7 +20670,6 @@ class JsonSerializationWriter {
             }
             if (this.shouldWriteValueOrNull(key, value)) {
                 key && this.writePropertyName(key);
-                // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
                 this.writer.push(`"${value}"`);
                 key && this.writer.push(JsonSerializationWriter.propertySeparator);
             }
@@ -20689,10 +20774,9 @@ class JsonSerializationWriter {
             }
         };
         this.writeNonParsableObjectValue = (key, value) => {
-            if (key) {
-                this.writePropertyName(key);
-            }
-            this.writer.push(JSON.stringify(value), JsonSerializationWriter.propertySeparator);
+            key && this.writePropertyName(key);
+            this.writer.push(JSON.stringify(value));
+            key && this.writer.push(JsonSerializationWriter.propertySeparator);
         };
         // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
         this.writeAnyValue = (key, value) => {
@@ -20743,6 +20827,7 @@ class JsonSerializationWriter {
         this.writeStringValue(key, b64);
     }
     writeObjectValue(key, value, serializerMethod) {
+        var _a, _b, _c;
         if (value === undefined) {
             return;
         }
@@ -20801,11 +20886,11 @@ class JsonSerializationWriter {
         }
         if (key)
             this.writePropertyName(key);
-        this.onBeforeObjectSerialization && this.onBeforeObjectSerialization(value);
+        (_a = this.onBeforeObjectSerialization) === null || _a === void 0 ? void 0 : _a.call(this, value);
         this.startObject();
-        this.onStartObjectSerialization && this.onStartObjectSerialization(value, this);
-        serializerMethod && serializerMethod(this, value);
-        this.onAfterObjectSerialization && this.onAfterObjectSerialization(value);
+        (_b = this.onStartObjectSerialization) === null || _b === void 0 ? void 0 : _b.call(this, value, this);
+        serializerMethod === null || serializerMethod === void 0 ? void 0 : serializerMethod(this, value);
+        (_c = this.onAfterObjectSerialization) === null || _c === void 0 ? void 0 : _c.call(this, value);
         this.removeLastSeparator();
         this.endObject();
         if (key)
@@ -20878,7 +20963,6 @@ class JsonSerializationWriterFactory {
  * See License in the project root for license information.
  * -------------------------------------------------------------------------------------------
  */
-/* eslint-disable @typescript-eslint/no-unused-expressions */
 /** Serialization writer for multipart/form-data */
 class MultipartSerializationWriter {
     constructor() {
@@ -20938,6 +21022,7 @@ class MultipartSerializationWriter {
             throw new Error(`serialization of collections is not supported with multipart`);
         };
         this.writeObjectValue = (key, value, serializerMethod) => {
+            var _a, _b, _c;
             if (!value) {
                 throw new Error(`value cannot be undefined`);
             }
@@ -20947,10 +21032,10 @@ class MultipartSerializationWriter {
             if (!serializerMethod) {
                 throw new Error(`serializer method cannot be undefined`);
             }
-            this.onBeforeObjectSerialization && this.onBeforeObjectSerialization(value);
-            this.onStartObjectSerialization && this.onStartObjectSerialization(value, this);
+            (_a = this.onBeforeObjectSerialization) === null || _a === void 0 ? void 0 : _a.call(this, value);
+            (_b = this.onStartObjectSerialization) === null || _b === void 0 ? void 0 : _b.call(this, value, this);
             serializerMethod(this, value);
-            this.onAfterObjectSerialization && this.onAfterObjectSerialization(value);
+            (_c = this.onAfterObjectSerialization) === null || _c === void 0 ? void 0 : _c.call(this, value);
         };
         this.writeEnumValue = (
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -21042,8 +21127,28 @@ class TextParseNode {
         this.getDateOnlyValue = () => DateOnly.parse(this.getStringValue());
         this.getTimeOnlyValue = () => TimeOnly.parse(this.getStringValue());
         this.getDurationValue = () => Duration.parse(this.getStringValue());
-        this.getCollectionOfPrimitiveValues = () => {
-            throw new Error(TextParseNode.noStructuredDataMessage);
+        this.getCollectionOfPrimitiveValues = (primitiveType) => {
+            return this.text.split(",").map((x) => {
+                const node = new TextParseNode(x);
+                switch (primitiveType) {
+                    case "boolean":
+                        return node.getBooleanValue();
+                    case "number":
+                        return node.getNumberValue();
+                    case "Date":
+                        return node.getDateValue();
+                    case "DateOnly":
+                        return node.getDateOnlyValue();
+                    case "TimeOnly":
+                        return node.getTimeOnlyValue();
+                    case "Duration":
+                        return node.getDurationValue();
+                    case "string":
+                        return node.getStringValue();
+                    default:
+                        throw new Error(`encountered an unsupported type during deserialization ${primitiveType}`);
+                }
+            });
         };
         this.getCollectionOfEnumValues = (type) => {
             throw new Error(TextParseNode.noStructuredDataMessage);
@@ -21074,7 +21179,7 @@ class TextParseNode {
              * TODO: Consider standardizing on a cross-platform UInt8Array.fromBase64 (after the API is stabilized across browsers)
              * in the future instead of the current environment-specific approach
              */
-            return inNodeEnv() ? new Uint8Array(Buffer.from(strValue, "base64")).buffer : new TextEncoder().encode(strValue);
+            return inNodeEnv() ? new Uint8Array(Buffer.from(strValue, "base64")).buffer : new TextEncoder().encode(strValue).buffer;
         }
         return undefined;
     }
@@ -21131,7 +21236,6 @@ class TextSerializationWriter {
                 return this.writeNullValue(key);
             }
             if (value) {
-                // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
                 this.writeStringValue(key, `"${value}"`);
             }
         };
@@ -21315,12 +21419,69 @@ const SalableNavigationMetadata = {
 /* tslint:enable */
 /* eslint-enable */
 
+/**
+ * Kiota's JsonSerializationWriter stringifies null enum values, producing
+ * `"interval": "null"` instead of `"interval": null`, which the API rejects
+ * with an invalid_enum_value error. Unlike every other write method, its
+ * writeEnumValue/writeCollectionOfEnumValues only filter out undefined before
+ * template-stringifying, so null slips through as the string "null".
+ * See https://github.com/microsoft/kiota-typescript — present up to at least
+ * 1.0.0-preview.107. This subclass emits a proper JSON null instead.
+ */
+class NullSafeJsonSerializationWriter extends JsonSerializationWriter {
+    writeEnumValue = (key, ...values) => {
+        const provided = values.filter((x) => x !== undefined);
+        if (provided.length === 0) {
+            return;
+        }
+        const rawValues = provided.filter((x) => x !== null).map((x) => `${x}`);
+        if (rawValues.length === 0) {
+            this.writeNullValue(key);
+            return;
+        }
+        this.writeStringValue(key, rawValues.join(', '));
+    };
+    writeCollectionOfEnumValues = (key, values) => {
+        if (values === null) {
+            this.writeNullValue(key);
+            return;
+        }
+        if (!values || values.length === 0) {
+            return;
+        }
+        const rawValues = values
+            .filter((x) => x !== undefined)
+            .map((x) => (x === null ? null : `${x}`));
+        if (rawValues.length === 0) {
+            return;
+        }
+        this.writeCollectionOfPrimitiveValues(key, rawValues);
+    };
+}
+class NullSafeJsonSerializationWriterFactory extends JsonSerializationWriterFactory {
+    getSerializationWriter(contentType) {
+        if (!contentType) {
+            throw new Error('content type cannot be undefined or empty');
+        }
+        if (this.getValidContentType() !== contentType) {
+            throw new Error(`expected a ${this.getValidContentType()} content type`);
+        }
+        return new NullSafeJsonSerializationWriter();
+    }
+}
+
 class Salable {
     api;
     constructor(apiKey) {
         const authProvider = new ApiKeyAuthenticationProvider('Bearer ' + apiKey, 'Authorization', ApiKeyLocation.Header);
         const adapter = new FetchRequestAdapter(authProvider);
         this.api = createSalable(adapter).api;
+        // Must run after createSalable, which registers the stock JSON serializer;
+        // re-registering replaces the application/json factory with the null-safe one.
+        const writerRegistry = adapter.getSerializationWriterFactory();
+        if (writerRegistry.registerDefaultSerializer) {
+            writerRegistry.registerDefaultSerializer(NullSafeJsonSerializationWriterFactory);
+        }
     }
 }