@alienplatform/sdk 1.10.7 → 1.11.1

package/dist/bearerTokenAuthenticationPolicy.js

@@ -0,0 +1,3028 @@
+import { i as __require, t as __commonJSMin } from "./rolldown-runtime.js";
+import { n as require_dist$1, r as require_src, t as require_dist$2 } from "./dist2.js";
+import { Readable } from "stream";
+import { Transform } from "node:stream";
+import os, { EOL } from "node:os";
+import process$1 from "node:process";
+import https from "node:https";
+import util, { inspect } from "node:util";
+import http from "node:http";
+import zlib from "node:zlib";
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/logger/log.js
+function log(message, ...args) {
+	process$1.stderr.write(`${util.format(message, ...args)}${EOL}`);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/logger/debug.js
+const debugEnvVariable = typeof process !== "undefined" && process.env && process.env.DEBUG || void 0;
+let enabledString;
+let enabledNamespaces = [];
+let skippedNamespaces = [];
+const debuggers = [];
+if (debugEnvVariable) enable(debugEnvVariable);
+const debugObj = Object.assign((namespace) => {
+	return createDebugger(namespace);
+}, {
+	enable,
+	enabled,
+	disable,
+	log
+});
+function enable(namespaces) {
+	enabledString = namespaces;
+	enabledNamespaces = [];
+	skippedNamespaces = [];
+	const namespaceList = namespaces.split(",").map((ns) => ns.trim());
+	for (const ns of namespaceList) if (ns.startsWith("-")) skippedNamespaces.push(ns.substring(1));
+	else enabledNamespaces.push(ns);
+	for (const instance of debuggers) instance.enabled = enabled(instance.namespace);
+}
+function enabled(namespace) {
+	if (namespace.endsWith("*")) return true;
+	for (const skipped of skippedNamespaces) if (namespaceMatches(namespace, skipped)) return false;
+	for (const enabledNamespace of enabledNamespaces) if (namespaceMatches(namespace, enabledNamespace)) return true;
+	return false;
+}
+/**
+* Given a namespace, check if it matches a pattern.
+* Patterns only have a single wildcard character which is *.
+* The behavior of * is that it matches zero or more other characters.
+*/
+function namespaceMatches(namespace, patternToMatch) {
+	if (patternToMatch.indexOf("*") === -1) return namespace === patternToMatch;
+	let pattern = patternToMatch;
+	if (patternToMatch.indexOf("**") !== -1) {
+		const patternParts = [];
+		let lastCharacter = "";
+		for (const character of patternToMatch) if (character === "*" && lastCharacter === "*") continue;
+		else {
+			lastCharacter = character;
+			patternParts.push(character);
+		}
+		pattern = patternParts.join("");
+	}
+	let namespaceIndex = 0;
+	let patternIndex = 0;
+	const patternLength = pattern.length;
+	const namespaceLength = namespace.length;
+	let lastWildcard = -1;
+	let lastWildcardNamespace = -1;
+	while (namespaceIndex < namespaceLength && patternIndex < patternLength) if (pattern[patternIndex] === "*") {
+		lastWildcard = patternIndex;
+		patternIndex++;
+		if (patternIndex === patternLength) return true;
+		while (namespace[namespaceIndex] !== pattern[patternIndex]) {
+			namespaceIndex++;
+			if (namespaceIndex === namespaceLength) return false;
+		}
+		lastWildcardNamespace = namespaceIndex;
+		namespaceIndex++;
+		patternIndex++;
+		continue;
+	} else if (pattern[patternIndex] === namespace[namespaceIndex]) {
+		patternIndex++;
+		namespaceIndex++;
+	} else if (lastWildcard >= 0) {
+		patternIndex = lastWildcard + 1;
+		namespaceIndex = lastWildcardNamespace + 1;
+		if (namespaceIndex === namespaceLength) return false;
+		while (namespace[namespaceIndex] !== pattern[patternIndex]) {
+			namespaceIndex++;
+			if (namespaceIndex === namespaceLength) return false;
+		}
+		lastWildcardNamespace = namespaceIndex;
+		namespaceIndex++;
+		patternIndex++;
+		continue;
+	} else return false;
+	const namespaceDone = namespaceIndex === namespace.length;
+	const patternDone = patternIndex === pattern.length;
+	const trailingWildCard = patternIndex === pattern.length - 1 && pattern[patternIndex] === "*";
+	return namespaceDone && (patternDone || trailingWildCard);
+}
+function disable() {
+	const result = enabledString || "";
+	enable("");
+	return result;
+}
+function createDebugger(namespace) {
+	const newDebugger = Object.assign(debug, {
+		enabled: enabled(namespace),
+		destroy,
+		log: debugObj.log,
+		namespace,
+		extend
+	});
+	function debug(...args) {
+		if (!newDebugger.enabled) return;
+		if (args.length > 0) args[0] = `${namespace} ${args[0]}`;
+		newDebugger.log(...args);
+	}
+	debuggers.push(newDebugger);
+	return newDebugger;
+}
+function destroy() {
+	const index = debuggers.indexOf(this);
+	if (index >= 0) {
+		debuggers.splice(index, 1);
+		return true;
+	}
+	return false;
+}
+function extend(namespace) {
+	const newDebugger = createDebugger(`${this.namespace}:${namespace}`);
+	newDebugger.log = this.log;
+	return newDebugger;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/logger/logger.js
+const TYPESPEC_RUNTIME_LOG_LEVELS = [
+	"verbose",
+	"info",
+	"warning",
+	"error"
+];
+const levelMap = {
+	verbose: 400,
+	info: 300,
+	warning: 200,
+	error: 100
+};
+function patchLogMethod(parent, child) {
+	child.log = (...args) => {
+		parent.log(...args);
+	};
+}
+function isTypeSpecRuntimeLogLevel(level) {
+	return TYPESPEC_RUNTIME_LOG_LEVELS.includes(level);
+}
+/**
+* Creates a logger context base on the provided options.
+* @param options - The options for creating a logger context.
+* @returns The logger context.
+*/
+function createLoggerContext(options) {
+	const registeredLoggers = /* @__PURE__ */ new Set();
+	const logLevelFromEnv = typeof process !== "undefined" && process.env && process.env[options.logLevelEnvVarName] || void 0;
+	let logLevel;
+	const clientLogger = debugObj(options.namespace);
+	clientLogger.log = (...args) => {
+		debugObj.log(...args);
+	};
+	function contextSetLogLevel(level) {
+		if (level && !isTypeSpecRuntimeLogLevel(level)) throw new Error(`Unknown log level '${level}'. Acceptable values: ${TYPESPEC_RUNTIME_LOG_LEVELS.join(",")}`);
+		logLevel = level;
+		const enabledNamespaces = [];
+		for (const logger of registeredLoggers) if (shouldEnable(logger)) enabledNamespaces.push(logger.namespace);
+		debugObj.enable(enabledNamespaces.join(","));
+	}
+	if (logLevelFromEnv) if (isTypeSpecRuntimeLogLevel(logLevelFromEnv)) contextSetLogLevel(logLevelFromEnv);
+	else console.error(`${options.logLevelEnvVarName} set to unknown log level '${logLevelFromEnv}'; logging is not enabled. Acceptable values: ${TYPESPEC_RUNTIME_LOG_LEVELS.join(", ")}.`);
+	function shouldEnable(logger) {
+		return Boolean(logLevel && levelMap[logger.level] <= levelMap[logLevel]);
+	}
+	function createLogger(parent, level) {
+		const logger = Object.assign(parent.extend(level), { level });
+		patchLogMethod(parent, logger);
+		if (shouldEnable(logger)) {
+			const enabledNamespaces = debugObj.disable();
+			debugObj.enable(enabledNamespaces + "," + logger.namespace);
+		}
+		registeredLoggers.add(logger);
+		return logger;
+	}
+	function contextGetLogLevel() {
+		return logLevel;
+	}
+	function contextCreateClientLogger(namespace) {
+		const clientRootLogger = clientLogger.extend(namespace);
+		patchLogMethod(clientLogger, clientRootLogger);
+		return {
+			error: createLogger(clientRootLogger, "error"),
+			warning: createLogger(clientRootLogger, "warning"),
+			info: createLogger(clientRootLogger, "info"),
+			verbose: createLogger(clientRootLogger, "verbose")
+		};
+	}
+	return {
+		setLogLevel: contextSetLogLevel,
+		getLogLevel: contextGetLogLevel,
+		createClientLogger: contextCreateClientLogger,
+		logger: clientLogger
+	};
+}
+const context$1 = createLoggerContext({
+	logLevelEnvVarName: "TYPESPEC_RUNTIME_LOG_LEVEL",
+	namespace: "typeSpecRuntime"
+});
+context$1.logger;
+/**
+* Creates a logger for use by the SDKs that inherits from `TypeSpecRuntimeLogger`.
+* @param namespace - The name of the SDK package.
+* @hidden
+*/
+function createClientLogger$1(namespace) {
+	return context$1.createClientLogger(namespace);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+logger@1.3.0/node_modules/@azure/logger/dist/esm/index.js
+const context = createLoggerContext({
+	logLevelEnvVarName: "AZURE_LOG_LEVEL",
+	namespace: "azure"
+});
+context.logger;
+/**
+* Retrieves the currently specified log level.
+*/
+function getLogLevel() {
+	return context.getLogLevel();
+}
+/**
+* Creates a logger for use by the Azure SDKs that inherits from `AzureLogger`.
+* @param namespace - The name of the SDK package.
+* @hidden
+*/
+function createClientLogger(namespace) {
+	return context.createClientLogger(namespace);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+core-tracing@1.3.1/node_modules/@azure/core-tracing/dist/esm/tracingContext.js
+/** @internal */
+const knownContextKeys = {
+	span: Symbol.for("@azure/core-tracing span"),
+	namespace: Symbol.for("@azure/core-tracing namespace")
+};
+/**
+* Creates a new {@link TracingContext} with the given options.
+* @param options - A set of known keys that may be set on the context.
+* @returns A new {@link TracingContext} with the given options.
+*
+* @internal
+*/
+function createTracingContext(options = {}) {
+	let context = new TracingContextImpl(options.parentContext);
+	if (options.span) context = context.setValue(knownContextKeys.span, options.span);
+	if (options.namespace) context = context.setValue(knownContextKeys.namespace, options.namespace);
+	return context;
+}
+/** @internal */
+var TracingContextImpl = class TracingContextImpl {
+	_contextMap;
+	constructor(initialContext) {
+		this._contextMap = initialContext instanceof TracingContextImpl ? new Map(initialContext._contextMap) : /* @__PURE__ */ new Map();
+	}
+	setValue(key, value) {
+		const newContext = new TracingContextImpl(this);
+		newContext._contextMap.set(key, value);
+		return newContext;
+	}
+	getValue(key) {
+		return this._contextMap.get(key);
+	}
+	deleteValue(key) {
+		const newContext = new TracingContextImpl(this);
+		newContext._contextMap.delete(key);
+		return newContext;
+	}
+};
+/**
+* Defines the shared state between CJS and ESM by re-exporting the CJS state.
+*/
+const state = (/* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.state = void 0;
+	/**
+	* @internal
+	*
+	* Holds the singleton instrumenter, to be shared across CJS and ESM imports.
+	*/
+	exports.state = { instrumenterImplementation: void 0 };
+})))().state;
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+core-tracing@1.3.1/node_modules/@azure/core-tracing/dist/esm/instrumenter.js
+function createDefaultTracingSpan() {
+	return {
+		end: () => {},
+		isRecording: () => false,
+		recordException: () => {},
+		setAttribute: () => {},
+		setStatus: () => {},
+		addEvent: () => {}
+	};
+}
+function createDefaultInstrumenter() {
+	return {
+		createRequestHeaders: () => {
+			return {};
+		},
+		parseTraceparentHeader: () => {},
+		startSpan: (_name, spanOptions) => {
+			return {
+				span: createDefaultTracingSpan(),
+				tracingContext: createTracingContext({ parentContext: spanOptions.tracingContext })
+			};
+		},
+		withContext(_context, callback, ...callbackArgs) {
+			return callback(...callbackArgs);
+		}
+	};
+}
+/**
+* Gets the currently set instrumenter, a No-Op instrumenter by default.
+*
+* @returns The currently set instrumenter
+*/
+function getInstrumenter() {
+	if (!state.instrumenterImplementation) state.instrumenterImplementation = createDefaultInstrumenter();
+	return state.instrumenterImplementation;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+core-tracing@1.3.1/node_modules/@azure/core-tracing/dist/esm/tracingClient.js
+/**
+* Creates a new tracing client.
+*
+* @param options - Options used to configure the tracing client.
+* @returns - An instance of {@link TracingClient}.
+*/
+function createTracingClient(options) {
+	const { namespace, packageName, packageVersion } = options;
+	function startSpan(name, operationOptions, spanOptions) {
+		const startSpanResult = getInstrumenter().startSpan(name, {
+			...spanOptions,
+			packageName,
+			packageVersion,
+			tracingContext: operationOptions?.tracingOptions?.tracingContext
+		});
+		let tracingContext = startSpanResult.tracingContext;
+		const span = startSpanResult.span;
+		if (!tracingContext.getValue(knownContextKeys.namespace)) tracingContext = tracingContext.setValue(knownContextKeys.namespace, namespace);
+		span.setAttribute("az.namespace", tracingContext.getValue(knownContextKeys.namespace));
+		return {
+			span,
+			updatedOptions: Object.assign({}, operationOptions, { tracingOptions: {
+				...operationOptions?.tracingOptions,
+				tracingContext
+			} })
+		};
+	}
+	async function withSpan(name, operationOptions, callback, spanOptions) {
+		const { span, updatedOptions } = startSpan(name, operationOptions, spanOptions);
+		try {
+			const result = await withContext(updatedOptions.tracingOptions.tracingContext, () => Promise.resolve(callback(updatedOptions, span)));
+			span.setStatus({ status: "success" });
+			return result;
+		} catch (err) {
+			span.setStatus({
+				status: "error",
+				error: err
+			});
+			throw err;
+		} finally {
+			span.end();
+		}
+	}
+	function withContext(context, callback, ...callbackArgs) {
+		return getInstrumenter().withContext(context, callback, ...callbackArgs);
+	}
+	/**
+	* Parses a traceparent header value into a span identifier.
+	*
+	* @param traceparentHeader - The traceparent header to parse.
+	* @returns An implementation-specific identifier for the span.
+	*/
+	function parseTraceparentHeader(traceparentHeader) {
+		return getInstrumenter().parseTraceparentHeader(traceparentHeader);
+	}
+	/**
+	* Creates a set of request headers to propagate tracing information to a backend.
+	*
+	* @param tracingContext - The context containing the span to serialize.
+	* @returns The set of headers to add to a request.
+	*/
+	function createRequestHeaders(tracingContext) {
+		return getInstrumenter().createRequestHeaders(tracingContext);
+	}
+	return {
+		startSpan,
+		withSpan,
+		withContext,
+		parseTraceparentHeader,
+		createRequestHeaders
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/util/random.js
+/**
+* Returns a random integer value between a lower and upper bound,
+* inclusive of both bounds.
+* Note that this uses Math.random and isn't secure. If you need to use
+* this for any kind of security purpose, find a better source of random.
+* @param min - The smallest integer value allowed.
+* @param max - The largest integer value allowed.
+*/
+function getRandomIntegerInclusive(min, max) {
+	min = Math.ceil(min);
+	max = Math.floor(max);
+	return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/util/delay.js
+/**
+* Calculates the delay interval for retry attempts using exponential delay with jitter.
+* @param retryAttempt - The current retry attempt number.
+* @param config - The exponential retry configuration.
+* @returns An object containing the calculated retry delay.
+*/
+function calculateRetryDelay$1(retryAttempt, config) {
+	const exponentialDelay = config.retryDelayInMs * Math.pow(2, retryAttempt);
+	const clampedDelay = Math.min(config.maxRetryDelayInMs, exponentialDelay);
+	return { retryAfterInMs: clampedDelay / 2 + getRandomIntegerInclusive(0, clampedDelay / 2) };
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/util/object.js
+/**
+* Helper to determine when an input is a generic JS object.
+* @returns true when input is an object type that is not null, Array, RegExp, or Date.
+*/
+function isObject(input) {
+	return typeof input === "object" && input !== null && !Array.isArray(input) && !(input instanceof RegExp) && !(input instanceof Date);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/util/error.js
+/**
+* Typeguard for an error object shape (has name and message)
+* @param e - Something caught by a catch clause.
+*/
+function isError$1(e) {
+	if (isObject(e)) {
+		const hasName = typeof e.name === "string";
+		const hasMessage = typeof e.message === "string";
+		return hasName && hasMessage;
+	}
+	return false;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/util/uuidUtils.js
+/**
+* Generated Universally Unique Identifier
+*
+* @returns RFC4122 v4 UUID.
+*/
+function randomUUID() {
+	return crypto.randomUUID();
+}
+typeof window !== "undefined" && window.document;
+typeof self === "object" && typeof self?.importScripts === "function" && (self.constructor?.name === "DedicatedWorkerGlobalScope" || self.constructor?.name === "ServiceWorkerGlobalScope" || self.constructor?.name);
+typeof Deno !== "undefined" && typeof Deno.version !== "undefined" && Deno.version.deno;
+typeof Bun !== "undefined" && Bun.version;
+/**
+* A constant that indicates whether the environment the code is running is a Node.js compatible environment.
+*/
+const isNodeLike$1 = typeof globalThis.process !== "undefined" && Boolean(globalThis.process.version) && Boolean(globalThis.process.versions?.node);
+typeof navigator !== "undefined" && navigator?.product;
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/util/bytesEncoding.js
+/**
+* The helper that transforms bytes with specific character encoding into string
+* @param bytes - the uint8array bytes
+* @param format - the format we use to encode the byte
+* @returns a string of the encoded string
+*/
+function uint8ArrayToString$1(bytes, format) {
+	return Buffer.from(bytes).toString(format);
+}
+/**
+* The helper that transforms string to specific character encoded bytes array.
+* @param value - the string to be converted
+* @param format - the format we use to decode the value
+* @returns a uint8array
+*/
+function stringToUint8Array$1(value, format) {
+	return Buffer.from(value, format);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/util/sanitizer.js
+const RedactedString = "REDACTED";
+const defaultAllowedHeaderNames = [
+	"x-ms-client-request-id",
+	"x-ms-return-client-request-id",
+	"x-ms-useragent",
+	"x-ms-correlation-request-id",
+	"x-ms-request-id",
+	"client-request-id",
+	"ms-cv",
+	"return-client-request-id",
+	"traceparent",
+	"Access-Control-Allow-Credentials",
+	"Access-Control-Allow-Headers",
+	"Access-Control-Allow-Methods",
+	"Access-Control-Allow-Origin",
+	"Access-Control-Expose-Headers",
+	"Access-Control-Max-Age",
+	"Access-Control-Request-Headers",
+	"Access-Control-Request-Method",
+	"Origin",
+	"Accept",
+	"Accept-Encoding",
+	"Cache-Control",
+	"Connection",
+	"Content-Length",
+	"Content-Type",
+	"Date",
+	"ETag",
+	"Expires",
+	"If-Match",
+	"If-Modified-Since",
+	"If-None-Match",
+	"If-Unmodified-Since",
+	"Last-Modified",
+	"Pragma",
+	"Request-Id",
+	"Retry-After",
+	"Server",
+	"Transfer-Encoding",
+	"User-Agent",
+	"WWW-Authenticate"
+];
+const defaultAllowedQueryParameters = ["api-version"];
+/**
+* A utility class to sanitize objects for logging.
+*/
+var Sanitizer = class {
+	allowedHeaderNames;
+	allowedQueryParameters;
+	constructor({ additionalAllowedHeaderNames: allowedHeaderNames = [], additionalAllowedQueryParameters: allowedQueryParameters = [] } = {}) {
+		allowedHeaderNames = defaultAllowedHeaderNames.concat(allowedHeaderNames);
+		allowedQueryParameters = defaultAllowedQueryParameters.concat(allowedQueryParameters);
+		this.allowedHeaderNames = new Set(allowedHeaderNames.map((n) => n.toLowerCase()));
+		this.allowedQueryParameters = new Set(allowedQueryParameters.map((p) => p.toLowerCase()));
+	}
+	/**
+	* Sanitizes an object for logging.
+	* @param obj - The object to sanitize
+	* @returns - The sanitized object as a string
+	*/
+	sanitize(obj) {
+		const seen = /* @__PURE__ */ new Set();
+		return JSON.stringify(obj, (key, value) => {
+			if (value instanceof Error) return {
+				...value,
+				name: value.name,
+				message: value.message
+			};
+			if (key === "headers") return this.sanitizeHeaders(value);
+			else if (key === "url") return this.sanitizeUrl(value);
+			else if (key === "query") return this.sanitizeQuery(value);
+			else if (key === "body") return;
+			else if (key === "response") return;
+			else if (key === "operationSpec") return;
+			else if (Array.isArray(value) || isObject(value)) {
+				if (seen.has(value)) return "[Circular]";
+				seen.add(value);
+			}
+			return value;
+		}, 2);
+	}
+	/**
+	* Sanitizes a URL for logging.
+	* @param value - The URL to sanitize
+	* @returns - The sanitized URL as a string
+	*/
+	sanitizeUrl(value) {
+		if (typeof value !== "string" || value === null || value === "") return value;
+		const url = new URL(value);
+		if (!url.search) return value;
+		for (const [key] of url.searchParams) if (!this.allowedQueryParameters.has(key.toLowerCase())) url.searchParams.set(key, RedactedString);
+		return url.toString();
+	}
+	sanitizeHeaders(obj) {
+		const sanitized = {};
+		for (const key of Object.keys(obj)) if (this.allowedHeaderNames.has(key.toLowerCase())) sanitized[key] = obj[key];
+		else sanitized[key] = RedactedString;
+		return sanitized;
+	}
+	sanitizeQuery(value) {
+		if (typeof value !== "object" || value === null) return value;
+		const sanitized = {};
+		for (const k of Object.keys(value)) if (this.allowedQueryParameters.has(k.toLowerCase())) sanitized[k] = value[k];
+		else sanitized[k] = RedactedString;
+		return sanitized;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+abort-controller@2.1.2/node_modules/@azure/abort-controller/dist/esm/AbortError.js
+/**
+* This error is thrown when an asynchronous operation has been aborted.
+* Check for this error by testing the `name` that the name property of the
+* error matches `"AbortError"`.
+*
+* @example
+* ```ts
+* const controller = new AbortController();
+* controller.abort();
+* try {
+*   doAsyncWork(controller.signal)
+* } catch (e) {
+*   if (e.name === 'AbortError') {
+*     // handle abort error here.
+*   }
+* }
+* ```
+*/
+var AbortError$1 = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "AbortError";
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+core-util@1.13.1/node_modules/@azure/core-util/dist/esm/createAbortablePromise.js
+/**
+* Creates an abortable promise.
+* @param buildPromise - A function that takes the resolve and reject functions as parameters.
+* @param options - The options for the abortable promise.
+* @returns A promise that can be aborted.
+*/
+function createAbortablePromise(buildPromise, options) {
+	const { cleanupBeforeAbort, abortSignal, abortErrorMsg } = options ?? {};
+	return new Promise((resolve, reject) => {
+		function rejectOnAbort() {
+			reject(new AbortError$1(abortErrorMsg ?? "The operation was aborted."));
+		}
+		function removeListeners() {
+			abortSignal?.removeEventListener("abort", onAbort);
+		}
+		function onAbort() {
+			cleanupBeforeAbort?.();
+			removeListeners();
+			rejectOnAbort();
+		}
+		if (abortSignal?.aborted) return rejectOnAbort();
+		try {
+			buildPromise((x) => {
+				removeListeners();
+				resolve(x);
+			}, (x) => {
+				removeListeners();
+				reject(x);
+			});
+		} catch (err) {
+			reject(err);
+		}
+		abortSignal?.addEventListener("abort", onAbort);
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+core-util@1.13.1/node_modules/@azure/core-util/dist/esm/delay.js
+const StandardAbortMessage$1 = "The delay was aborted.";
+/**
+* A wrapper for setTimeout that resolves a promise after timeInMs milliseconds.
+* @param timeInMs - The number of milliseconds to be delayed.
+* @param options - The options for delay - currently abort options
+* @returns Promise that is resolved after timeInMs
+*/
+function delay$1(timeInMs, options) {
+	let token;
+	const { abortSignal, abortErrorMsg } = options ?? {};
+	return createAbortablePromise((resolve) => {
+		token = setTimeout(resolve, timeInMs);
+	}, {
+		cleanupBeforeAbort: () => clearTimeout(token),
+		abortSignal,
+		abortErrorMsg: abortErrorMsg ?? StandardAbortMessage$1
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+core-util@1.13.1/node_modules/@azure/core-util/dist/esm/error.js
+/**
+* Given what is thought to be an error object, return the message if possible.
+* If the message is missing, returns a stringified version of the input.
+* @param e - Something thrown from a try block
+* @returns The error message or a string of the input
+*/
+function getErrorMessage(e) {
+	if (isError$1(e)) return e.message;
+	else {
+		let stringified;
+		try {
+			if (typeof e === "object" && e) stringified = JSON.stringify(e);
+			else stringified = String(e);
+		} catch (err) {
+			stringified = "[unable to stringify input]";
+		}
+		return `Unknown error ${stringified}`;
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+core-util@1.13.1/node_modules/@azure/core-util/dist/esm/typeGuards.js
+/**
+* Helper TypeGuard that checks if something is defined or not.
+* @param thing - Anything
+*/
+function isDefined(thing) {
+	return typeof thing !== "undefined" && thing !== null;
+}
+/**
+* Helper TypeGuard that checks if the input is an object with the specified properties.
+* @param thing - Anything.
+* @param properties - The name of the properties that should appear in the object.
+*/
+function isObjectWithProperties(thing, properties) {
+	if (!isDefined(thing) || typeof thing !== "object") return false;
+	for (const property of properties) if (!objectHasProperty(thing, property)) return false;
+	return true;
+}
+/**
+* Helper TypeGuard that checks if the input is an object with the specified property.
+* @param thing - Any object.
+* @param property - The name of the property that should appear in the object.
+*/
+function objectHasProperty(thing, property) {
+	return isDefined(thing) && typeof thing === "object" && property in thing;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+core-util@1.13.1/node_modules/@azure/core-util/dist/esm/index.js
+/**
+* Calculates the delay interval for retry attempts using exponential delay with jitter.
+*
+* @param retryAttempt - The current retry attempt number.
+*
+* @param config - The exponential retry configuration.
+*
+* @returns An object containing the calculated retry delay.
+*/
+function calculateRetryDelay(retryAttempt, config) {
+	return calculateRetryDelay$1(retryAttempt, config);
+}
+/**
+* Typeguard for an error object shape (has name and message)
+*
+* @param e - Something caught by a catch clause.
+*/
+function isError(e) {
+	return isError$1(e);
+}
+/**
+* A constant that indicates whether the environment the code is running is a Node.js compatible environment.
+*
+* @deprecated
+*
+* Use `isNodeLike` instead.
+*/
+const isNode = isNodeLike$1;
+/**
+* A constant that indicates whether the environment the code is running is a Node.js compatible environment.
+*/
+const isNodeLike = isNodeLike$1;
+/**
+* The helper that transforms bytes with specific character encoding into string
+* @param bytes - the uint8array bytes
+* @param format - the format we use to encode the byte
+* @returns a string of the encoded string
+*/
+function uint8ArrayToString(bytes, format) {
+	return uint8ArrayToString$1(bytes, format);
+}
+/**
+* The helper that transforms string to specific character encoded bytes array.
+* @param value - the string to be converted
+* @param format - the format we use to decode the value
+* @returns a uint8array
+*/
+function stringToUint8Array(value, format) {
+	return stringToUint8Array$1(value, format);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/httpHeaders.js
+function normalizeName(name) {
+	return name.toLowerCase();
+}
+function* headerIterator(map) {
+	for (const entry of map.values()) yield [entry.name, entry.value];
+}
+var HttpHeadersImpl = class {
+	_headersMap;
+	constructor(rawHeaders) {
+		this._headersMap = /* @__PURE__ */ new Map();
+		if (rawHeaders) for (const headerName of Object.keys(rawHeaders)) this.set(headerName, rawHeaders[headerName]);
+	}
+	/**
+	* Set a header in this collection with the provided name and value. The name is
+	* case-insensitive.
+	* @param name - The name of the header to set. This value is case-insensitive.
+	* @param value - The value of the header to set.
+	*/
+	set(name, value) {
+		this._headersMap.set(normalizeName(name), {
+			name,
+			value: String(value).trim()
+		});
+	}
+	/**
+	* Get the header value for the provided header name, or undefined if no header exists in this
+	* collection with the provided name.
+	* @param name - The name of the header. This value is case-insensitive.
+	*/
+	get(name) {
+		return this._headersMap.get(normalizeName(name))?.value;
+	}
+	/**
+	* Get whether or not this header collection contains a header entry for the provided header name.
+	* @param name - The name of the header to set. This value is case-insensitive.
+	*/
+	has(name) {
+		return this._headersMap.has(normalizeName(name));
+	}
+	/**
+	* Remove the header with the provided headerName.
+	* @param name - The name of the header to remove.
+	*/
+	delete(name) {
+		this._headersMap.delete(normalizeName(name));
+	}
+	/**
+	* Get the JSON object representation of this HTTP header collection.
+	*/
+	toJSON(options = {}) {
+		const result = {};
+		if (options.preserveCase) for (const entry of this._headersMap.values()) result[entry.name] = entry.value;
+		else for (const [normalizedName, entry] of this._headersMap) result[normalizedName] = entry.value;
+		return result;
+	}
+	/**
+	* Get the string representation of this HTTP header collection.
+	*/
+	toString() {
+		return JSON.stringify(this.toJSON({ preserveCase: true }));
+	}
+	/**
+	* Iterate over tuples of header [name, value] pairs.
+	*/
+	[Symbol.iterator]() {
+		return headerIterator(this._headersMap);
+	}
+};
+/**
+* Creates an object that satisfies the `HttpHeaders` interface.
+* @param rawHeaders - A simple object representing initial headers
+*/
+function createHttpHeaders(rawHeaders) {
+	return new HttpHeadersImpl(rawHeaders);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/pipelineRequest.js
+var PipelineRequestImpl = class {
+	url;
+	method;
+	headers;
+	timeout;
+	withCredentials;
+	body;
+	multipartBody;
+	formData;
+	streamResponseStatusCodes;
+	enableBrowserStreams;
+	proxySettings;
+	disableKeepAlive;
+	abortSignal;
+	requestId;
+	allowInsecureConnection;
+	onUploadProgress;
+	onDownloadProgress;
+	requestOverrides;
+	authSchemes;
+	constructor(options) {
+		this.url = options.url;
+		this.body = options.body;
+		this.headers = options.headers ?? createHttpHeaders();
+		this.method = options.method ?? "GET";
+		this.timeout = options.timeout ?? 0;
+		this.multipartBody = options.multipartBody;
+		this.formData = options.formData;
+		this.disableKeepAlive = options.disableKeepAlive ?? false;
+		this.proxySettings = options.proxySettings;
+		this.streamResponseStatusCodes = options.streamResponseStatusCodes;
+		this.withCredentials = options.withCredentials ?? false;
+		this.abortSignal = options.abortSignal;
+		this.onUploadProgress = options.onUploadProgress;
+		this.onDownloadProgress = options.onDownloadProgress;
+		this.requestId = options.requestId || randomUUID();
+		this.allowInsecureConnection = options.allowInsecureConnection ?? false;
+		this.enableBrowserStreams = options.enableBrowserStreams ?? false;
+		this.requestOverrides = options.requestOverrides;
+		this.authSchemes = options.authSchemes;
+	}
+};
+/**
+* Creates a new pipeline request with the given options.
+* This method is to allow for the easy setting of default values and not required.
+* @param options - The options to create the request with.
+*/
+function createPipelineRequest(options) {
+	return new PipelineRequestImpl(options);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/pipeline.js
+const ValidPhaseNames = new Set([
+	"Deserialize",
+	"Serialize",
+	"Retry",
+	"Sign"
+]);
+/**
+* A private implementation of Pipeline.
+* Do not export this class from the package.
+* @internal
+*/
+var HttpPipeline = class HttpPipeline {
+	_policies = [];
+	_orderedPolicies;
+	constructor(policies) {
+		this._policies = policies?.slice(0) ?? [];
+		this._orderedPolicies = void 0;
+	}
+	addPolicy(policy, options = {}) {
+		if (options.phase && options.afterPhase) throw new Error("Policies inside a phase cannot specify afterPhase.");
+		if (options.phase && !ValidPhaseNames.has(options.phase)) throw new Error(`Invalid phase name: ${options.phase}`);
+		if (options.afterPhase && !ValidPhaseNames.has(options.afterPhase)) throw new Error(`Invalid afterPhase name: ${options.afterPhase}`);
+		this._policies.push({
+			policy,
+			options
+		});
+		this._orderedPolicies = void 0;
+	}
+	removePolicy(options) {
+		const removedPolicies = [];
+		this._policies = this._policies.filter((policyDescriptor) => {
+			if (options.name && policyDescriptor.policy.name === options.name || options.phase && policyDescriptor.options.phase === options.phase) {
+				removedPolicies.push(policyDescriptor.policy);
+				return false;
+			} else return true;
+		});
+		this._orderedPolicies = void 0;
+		return removedPolicies;
+	}
+	sendRequest(httpClient, request) {
+		return this.getOrderedPolicies().reduceRight((next, policy) => {
+			return (req) => {
+				return policy.sendRequest(req, next);
+			};
+		}, (req) => httpClient.sendRequest(req))(request);
+	}
+	getOrderedPolicies() {
+		if (!this._orderedPolicies) this._orderedPolicies = this.orderPolicies();
+		return this._orderedPolicies;
+	}
+	clone() {
+		return new HttpPipeline(this._policies);
+	}
+	static create() {
+		return new HttpPipeline();
+	}
+	orderPolicies() {
+		/**
+		* The goal of this method is to reliably order pipeline policies
+		* based on their declared requirements when they were added.
+		*
+		* Order is first determined by phase:
+		*
+		* 1. Serialize Phase
+		* 2. Policies not in a phase
+		* 3. Deserialize Phase
+		* 4. Retry Phase
+		* 5. Sign Phase
+		*
+		* Within each phase, policies are executed in the order
+		* they were added unless they were specified to execute
+		* before/after other policies or after a particular phase.
+		*
+		* To determine the final order, we will walk the policy list
+		* in phase order multiple times until all dependencies are
+		* satisfied.
+		*
+		* `afterPolicies` are the set of policies that must be
+		* executed before a given policy. This requirement is
+		* considered satisfied when each of the listed policies
+		* have been scheduled.
+		*
+		* `beforePolicies` are the set of policies that must be
+		* executed after a given policy. Since this dependency
+		* can be expressed by converting it into a equivalent
+		* `afterPolicies` declarations, they are normalized
+		* into that form for simplicity.
+		*
+		* An `afterPhase` dependency is considered satisfied when all
+		* policies in that phase have scheduled.
+		*
+		*/
+		const result = [];
+		const policyMap = /* @__PURE__ */ new Map();
+		function createPhase(name) {
+			return {
+				name,
+				policies: /* @__PURE__ */ new Set(),
+				hasRun: false,
+				hasAfterPolicies: false
+			};
+		}
+		const serializePhase = createPhase("Serialize");
+		const noPhase = createPhase("None");
+		const deserializePhase = createPhase("Deserialize");
+		const retryPhase = createPhase("Retry");
+		const signPhase = createPhase("Sign");
+		const orderedPhases = [
+			serializePhase,
+			noPhase,
+			deserializePhase,
+			retryPhase,
+			signPhase
+		];
+		function getPhase(phase) {
+			if (phase === "Retry") return retryPhase;
+			else if (phase === "Serialize") return serializePhase;
+			else if (phase === "Deserialize") return deserializePhase;
+			else if (phase === "Sign") return signPhase;
+			else return noPhase;
+		}
+		for (const descriptor of this._policies) {
+			const policy = descriptor.policy;
+			const options = descriptor.options;
+			const policyName = policy.name;
+			if (policyMap.has(policyName)) throw new Error("Duplicate policy names not allowed in pipeline");
+			const node = {
+				policy,
+				dependsOn: /* @__PURE__ */ new Set(),
+				dependants: /* @__PURE__ */ new Set()
+			};
+			if (options.afterPhase) {
+				node.afterPhase = getPhase(options.afterPhase);
+				node.afterPhase.hasAfterPolicies = true;
+			}
+			policyMap.set(policyName, node);
+			getPhase(options.phase).policies.add(node);
+		}
+		for (const descriptor of this._policies) {
+			const { policy, options } = descriptor;
+			const policyName = policy.name;
+			const node = policyMap.get(policyName);
+			if (!node) throw new Error(`Missing node for policy ${policyName}`);
+			if (options.afterPolicies) for (const afterPolicyName of options.afterPolicies) {
+				const afterNode = policyMap.get(afterPolicyName);
+				if (afterNode) {
+					node.dependsOn.add(afterNode);
+					afterNode.dependants.add(node);
+				}
+			}
+			if (options.beforePolicies) for (const beforePolicyName of options.beforePolicies) {
+				const beforeNode = policyMap.get(beforePolicyName);
+				if (beforeNode) {
+					beforeNode.dependsOn.add(node);
+					node.dependants.add(beforeNode);
+				}
+			}
+		}
+		function walkPhase(phase) {
+			phase.hasRun = true;
+			for (const node of phase.policies) {
+				if (node.afterPhase && (!node.afterPhase.hasRun || node.afterPhase.policies.size)) continue;
+				if (node.dependsOn.size === 0) {
+					result.push(node.policy);
+					for (const dependant of node.dependants) dependant.dependsOn.delete(node);
+					policyMap.delete(node.policy.name);
+					phase.policies.delete(node);
+				}
+			}
+		}
+		function walkPhases() {
+			for (const phase of orderedPhases) {
+				walkPhase(phase);
+				if (phase.policies.size > 0 && phase !== noPhase) {
+					if (!noPhase.hasRun) walkPhase(noPhase);
+					return;
+				}
+				if (phase.hasAfterPolicies) walkPhase(noPhase);
+			}
+		}
+		let iteration = 0;
+		while (policyMap.size > 0) {
+			iteration++;
+			const initialResultLength = result.length;
+			walkPhases();
+			if (result.length <= initialResultLength && iteration > 1) throw new Error("Cannot satisfy policy dependencies due to requirements cycle.");
+		}
+		return result;
+	}
+};
+/**
+* Creates a totally empty pipeline.
+* Useful for testing or creating a custom one.
+*/
+function createEmptyPipeline$1() {
+	return HttpPipeline.create();
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/util/inspect.js
+const custom = inspect.custom;
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/restError.js
+const errorSanitizer = new Sanitizer();
+/**
+* A custom error type for failed pipeline requests.
+*/
+var RestError$1 = class RestError$1 extends Error {
+	/**
+	* Something went wrong when making the request.
+	* This means the actual request failed for some reason,
+	* such as a DNS issue or the connection being lost.
+	*/
+	static REQUEST_SEND_ERROR = "REQUEST_SEND_ERROR";
+	/**
+	* This means that parsing the response from the server failed.
+	* It may have been malformed.
+	*/
+	static PARSE_ERROR = "PARSE_ERROR";
+	/**
+	* The code of the error itself (use statics on RestError if possible.)
+	*/
+	code;
+	/**
+	* The HTTP status code of the request (if applicable.)
+	*/
+	statusCode;
+	/**
+	* The request that was made.
+	* This property is non-enumerable.
+	*/
+	request;
+	/**
+	* The response received (if any.)
+	* This property is non-enumerable.
+	*/
+	response;
+	/**
+	* Bonus property set by the throw site.
+	*/
+	details;
+	constructor(message, options = {}) {
+		super(message);
+		this.name = "RestError";
+		this.code = options.code;
+		this.statusCode = options.statusCode;
+		Object.defineProperty(this, "request", {
+			value: options.request,
+			enumerable: false
+		});
+		Object.defineProperty(this, "response", {
+			value: options.response,
+			enumerable: false
+		});
+		const agent = this.request?.agent ? {
+			maxFreeSockets: this.request.agent.maxFreeSockets,
+			maxSockets: this.request.agent.maxSockets
+		} : void 0;
+		Object.defineProperty(this, custom, {
+			value: () => {
+				return `RestError: ${this.message} \n ${errorSanitizer.sanitize({
+					...this,
+					request: {
+						...this.request,
+						agent
+					},
+					response: this.response
+				})}`;
+			},
+			enumerable: false
+		});
+		Object.setPrototypeOf(this, RestError$1.prototype);
+	}
+};
+/**
+* Typeguard for RestError
+* @param e - Something caught by a catch clause.
+*/
+function isRestError$1(e) {
+	if (e instanceof RestError$1) return true;
+	return isError$1(e) && e.name === "RestError";
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/abort-controller/AbortError.js
+/**
+* This error is thrown when an asynchronous operation has been aborted.
+* Check for this error by testing the `name` that the name property of the
+* error matches `"AbortError"`.
+*
+* @example
+* ```ts snippet:ReadmeSampleAbortError
+* import { AbortError } from "@typespec/ts-http-runtime";
+*
+* async function doAsyncWork(options: { abortSignal: AbortSignal }): Promise<void> {
+*   if (options.abortSignal.aborted) {
+*     throw new AbortError();
+*   }
+*
+*   // do async work
+* }
+*
+* const controller = new AbortController();
+* controller.abort();
+*
+* try {
+*   doAsyncWork({ abortSignal: controller.signal });
+* } catch (e) {
+*   if (e instanceof Error && e.name === "AbortError") {
+*     // handle abort error here.
+*   }
+* }
+* ```
+*/
+var AbortError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "AbortError";
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/log.js
+const logger$1 = createClientLogger$1("ts-http-runtime");
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/nodeHttpClient.js
+const DEFAULT_TLS_SETTINGS = {};
+function isReadableStream$1(body) {
+	return body && typeof body.pipe === "function";
+}
+function isStreamComplete(stream) {
+	if (stream.readable === false) return Promise.resolve();
+	return new Promise((resolve) => {
+		const handler = () => {
+			resolve();
+			stream.removeListener("close", handler);
+			stream.removeListener("end", handler);
+			stream.removeListener("error", handler);
+		};
+		stream.on("close", handler);
+		stream.on("end", handler);
+		stream.on("error", handler);
+	});
+}
+function isArrayBuffer(body) {
+	return body && typeof body.byteLength === "number";
+}
+var ReportTransform = class extends Transform {
+	loadedBytes = 0;
+	progressCallback;
+	_transform(chunk, _encoding, callback) {
+		this.push(chunk);
+		this.loadedBytes += chunk.length;
+		try {
+			this.progressCallback({ loadedBytes: this.loadedBytes });
+			callback();
+		} catch (e) {
+			callback(e);
+		}
+	}
+	constructor(progressCallback) {
+		super();
+		this.progressCallback = progressCallback;
+	}
+};
+/**
+* A HttpClient implementation that uses Node's "https" module to send HTTPS requests.
+* @internal
+*/
+var NodeHttpClient = class {
+	cachedHttpAgent;
+	cachedHttpsAgents = /* @__PURE__ */ new WeakMap();
+	/**
+	* Makes a request over an underlying transport layer and returns the response.
+	* @param request - The request to be made.
+	*/
+	async sendRequest(request) {
+		const abortController = new AbortController();
+		let abortListener;
+		if (request.abortSignal) {
+			if (request.abortSignal.aborted) throw new AbortError("The operation was aborted. Request has already been canceled.");
+			abortListener = (event) => {
+				if (event.type === "abort") abortController.abort();
+			};
+			request.abortSignal.addEventListener("abort", abortListener);
+		}
+		let timeoutId;
+		if (request.timeout > 0) timeoutId = setTimeout(() => {
+			const sanitizer = new Sanitizer();
+			logger$1.info(`request to '${sanitizer.sanitizeUrl(request.url)}' timed out. canceling...`);
+			abortController.abort();
+		}, request.timeout);
+		const acceptEncoding = request.headers.get("Accept-Encoding");
+		const shouldDecompress = acceptEncoding?.includes("gzip") || acceptEncoding?.includes("deflate");
+		let body = typeof request.body === "function" ? request.body() : request.body;
+		if (body && !request.headers.has("Content-Length")) {
+			const bodyLength = getBodyLength(body);
+			if (bodyLength !== null) request.headers.set("Content-Length", bodyLength);
+		}
+		let responseStream;
+		try {
+			if (body && request.onUploadProgress) {
+				const onUploadProgress = request.onUploadProgress;
+				const uploadReportStream = new ReportTransform(onUploadProgress);
+				uploadReportStream.on("error", (e) => {
+					logger$1.error("Error in upload progress", e);
+				});
+				if (isReadableStream$1(body)) body.pipe(uploadReportStream);
+				else uploadReportStream.end(body);
+				body = uploadReportStream;
+			}
+			const res = await this.makeRequest(request, abortController, body);
+			if (timeoutId !== void 0) clearTimeout(timeoutId);
+			const headers = getResponseHeaders(res);
+			const response = {
+				status: res.statusCode ?? 0,
+				headers,
+				request
+			};
+			if (request.method === "HEAD") {
+				res.resume();
+				return response;
+			}
+			responseStream = shouldDecompress ? getDecodedResponseStream(res, headers) : res;
+			const onDownloadProgress = request.onDownloadProgress;
+			if (onDownloadProgress) {
+				const downloadReportStream = new ReportTransform(onDownloadProgress);
+				downloadReportStream.on("error", (e) => {
+					logger$1.error("Error in download progress", e);
+				});
+				responseStream.pipe(downloadReportStream);
+				responseStream = downloadReportStream;
+			}
+			if (request.streamResponseStatusCodes?.has(Number.POSITIVE_INFINITY) || request.streamResponseStatusCodes?.has(response.status)) response.readableStreamBody = responseStream;
+			else response.bodyAsText = await streamToText(responseStream);
+			return response;
+		} finally {
+			if (request.abortSignal && abortListener) {
+				let uploadStreamDone = Promise.resolve();
+				if (isReadableStream$1(body)) uploadStreamDone = isStreamComplete(body);
+				let downloadStreamDone = Promise.resolve();
+				if (isReadableStream$1(responseStream)) downloadStreamDone = isStreamComplete(responseStream);
+				Promise.all([uploadStreamDone, downloadStreamDone]).then(() => {
+					if (abortListener) request.abortSignal?.removeEventListener("abort", abortListener);
+				}).catch((e) => {
+					logger$1.warning("Error when cleaning up abortListener on httpRequest", e);
+				});
+			}
+		}
+	}
+	makeRequest(request, abortController, body) {
+		const url = new URL(request.url);
+		const isInsecure = url.protocol !== "https:";
+		if (isInsecure && !request.allowInsecureConnection) throw new Error(`Cannot connect to ${request.url} while allowInsecureConnection is false.`);
+		const options = {
+			agent: request.agent ?? this.getOrCreateAgent(request, isInsecure),
+			hostname: url.hostname,
+			path: `${url.pathname}${url.search}`,
+			port: url.port,
+			method: request.method,
+			headers: request.headers.toJSON({ preserveCase: true }),
+			...request.requestOverrides
+		};
+		return new Promise((resolve, reject) => {
+			const req = isInsecure ? http.request(options, resolve) : https.request(options, resolve);
+			req.once("error", (err) => {
+				reject(new RestError$1(err.message, {
+					code: err.code ?? RestError$1.REQUEST_SEND_ERROR,
+					request
+				}));
+			});
+			abortController.signal.addEventListener("abort", () => {
+				const abortError = new AbortError("The operation was aborted. Rejecting from abort signal callback while making request.");
+				req.destroy(abortError);
+				reject(abortError);
+			});
+			if (body && isReadableStream$1(body)) body.pipe(req);
+			else if (body) if (typeof body === "string" || Buffer.isBuffer(body)) req.end(body);
+			else if (isArrayBuffer(body)) req.end(ArrayBuffer.isView(body) ? Buffer.from(body.buffer) : Buffer.from(body));
+			else {
+				logger$1.error("Unrecognized body type", body);
+				reject(new RestError$1("Unrecognized body type"));
+			}
+			else req.end();
+		});
+	}
+	getOrCreateAgent(request, isInsecure) {
+		const disableKeepAlive = request.disableKeepAlive;
+		if (isInsecure) {
+			if (disableKeepAlive) return http.globalAgent;
+			if (!this.cachedHttpAgent) this.cachedHttpAgent = new http.Agent({ keepAlive: true });
+			return this.cachedHttpAgent;
+		} else {
+			if (disableKeepAlive && !request.tlsSettings) return https.globalAgent;
+			const tlsSettings = request.tlsSettings ?? DEFAULT_TLS_SETTINGS;
+			let agent = this.cachedHttpsAgents.get(tlsSettings);
+			if (agent && agent.options.keepAlive === !disableKeepAlive) return agent;
+			logger$1.info("No cached TLS Agent exist, creating a new Agent");
+			agent = new https.Agent({
+				keepAlive: !disableKeepAlive,
+				...tlsSettings
+			});
+			this.cachedHttpsAgents.set(tlsSettings, agent);
+			return agent;
+		}
+	}
+};
+function getResponseHeaders(res) {
+	const headers = createHttpHeaders();
+	for (const header of Object.keys(res.headers)) {
+		const value = res.headers[header];
+		if (Array.isArray(value)) {
+			if (value.length > 0) headers.set(header, value[0]);
+		} else if (value) headers.set(header, value);
+	}
+	return headers;
+}
+function getDecodedResponseStream(stream, headers) {
+	const contentEncoding = headers.get("Content-Encoding");
+	if (contentEncoding === "gzip") {
+		const unzip = zlib.createGunzip();
+		stream.pipe(unzip);
+		return unzip;
+	} else if (contentEncoding === "deflate") {
+		const inflate = zlib.createInflate();
+		stream.pipe(inflate);
+		return inflate;
+	}
+	return stream;
+}
+function streamToText(stream) {
+	return new Promise((resolve, reject) => {
+		const buffer = [];
+		stream.on("data", (chunk) => {
+			if (Buffer.isBuffer(chunk)) buffer.push(chunk);
+			else buffer.push(Buffer.from(chunk));
+		});
+		stream.on("end", () => {
+			resolve(Buffer.concat(buffer).toString("utf8"));
+		});
+		stream.on("error", (e) => {
+			if (e && e?.name === "AbortError") reject(e);
+			else reject(new RestError$1(`Error reading response as text: ${e.message}`, { code: RestError$1.PARSE_ERROR }));
+		});
+	});
+}
+/** @internal */
+function getBodyLength(body) {
+	if (!body) return 0;
+	else if (Buffer.isBuffer(body)) return body.length;
+	else if (isReadableStream$1(body)) return null;
+	else if (isArrayBuffer(body)) return body.byteLength;
+	else if (typeof body === "string") return Buffer.from(body).length;
+	else return null;
+}
+/**
+* Create a new HttpClient instance for the NodeJS environment.
+* @internal
+*/
+function createNodeHttpClient() {
+	return new NodeHttpClient();
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/defaultHttpClient.js
+/**
+* Create the correct HttpClient for the current environment.
+*/
+function createDefaultHttpClient() {
+	return createNodeHttpClient();
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/policies/logPolicy.js
+/**
+* The programmatic identifier of the logPolicy.
+*/
+const logPolicyName = "logPolicy";
+/**
+* A policy that logs all requests and responses.
+* @param options - Options to configure logPolicy.
+*/
+function logPolicy$1(options = {}) {
+	const logger = options.logger ?? logger$1.info;
+	const sanitizer = new Sanitizer({
+		additionalAllowedHeaderNames: options.additionalAllowedHeaderNames,
+		additionalAllowedQueryParameters: options.additionalAllowedQueryParameters
+	});
+	return {
+		name: logPolicyName,
+		async sendRequest(request, next) {
+			if (!logger.enabled) return next(request);
+			logger(`Request: ${sanitizer.sanitize(request)}`);
+			const response = await next(request);
+			logger(`Response status code: ${response.status}`);
+			logger(`Headers: ${sanitizer.sanitize(response.headers)}`);
+			return response;
+		}
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/policies/redirectPolicy.js
+/**
+* The programmatic identifier of the redirectPolicy.
+*/
+const redirectPolicyName = "redirectPolicy";
+/**
+* Methods that are allowed to follow redirects 301 and 302
+*/
+const allowedRedirect = ["GET", "HEAD"];
+/**
+* A policy to follow Location headers from the server in order
+* to support server-side redirection.
+* In the browser, this policy is not used.
+* @param options - Options to control policy behavior.
+*/
+function redirectPolicy$1(options = {}) {
+	const { maxRetries = 20 } = options;
+	return {
+		name: redirectPolicyName,
+		async sendRequest(request, next) {
+			return handleRedirect(next, await next(request), maxRetries);
+		}
+	};
+}
+async function handleRedirect(next, response, maxRetries, currentRetries = 0) {
+	const { request, status, headers } = response;
+	const locationHeader = headers.get("location");
+	if (locationHeader && (status === 300 || status === 301 && allowedRedirect.includes(request.method) || status === 302 && allowedRedirect.includes(request.method) || status === 303 && request.method === "POST" || status === 307) && currentRetries < maxRetries) {
+		request.url = new URL(locationHeader, request.url).toString();
+		if (status === 303) {
+			request.method = "GET";
+			request.headers.delete("Content-Length");
+			delete request.body;
+		}
+		request.headers.delete("Authorization");
+		return handleRedirect(next, await next(request), maxRetries, currentRetries + 1);
+	}
+	return response;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/constants.js
+const SDK_VERSION$1 = "0.3.2";
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/policies/decompressResponsePolicy.js
+/**
+* The programmatic identifier of the decompressResponsePolicy.
+*/
+const decompressResponsePolicyName = "decompressResponsePolicy";
+/**
+* A policy to enable response decompression according to Accept-Encoding header
+* https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept-Encoding
+*/
+function decompressResponsePolicy$1() {
+	return {
+		name: decompressResponsePolicyName,
+		async sendRequest(request, next) {
+			if (request.method !== "HEAD") request.headers.set("Accept-Encoding", "gzip,deflate");
+			return next(request);
+		}
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/util/helpers.js
+const StandardAbortMessage = "The operation was aborted.";
+/**
+* A wrapper for setTimeout that resolves a promise after delayInMs milliseconds.
+* @param delayInMs - The number of milliseconds to be delayed.
+* @param value - The value to be resolved with after a timeout of t milliseconds.
+* @param options - The options for delay - currently abort options
+*                  - abortSignal - The abortSignal associated with containing operation.
+*                  - abortErrorMsg - The abort error message associated with containing operation.
+* @returns Resolved promise
+*/
+function delay(delayInMs, value, options) {
+	return new Promise((resolve, reject) => {
+		let timer = void 0;
+		let onAborted = void 0;
+		const rejectOnAbort = () => {
+			return reject(new AbortError(options?.abortErrorMsg ? options?.abortErrorMsg : StandardAbortMessage));
+		};
+		const removeListeners = () => {
+			if (options?.abortSignal && onAborted) options.abortSignal.removeEventListener("abort", onAborted);
+		};
+		onAborted = () => {
+			if (timer) clearTimeout(timer);
+			removeListeners();
+			return rejectOnAbort();
+		};
+		if (options?.abortSignal && options.abortSignal.aborted) return rejectOnAbort();
+		timer = setTimeout(() => {
+			removeListeners();
+			resolve(value);
+		}, delayInMs);
+		if (options?.abortSignal) options.abortSignal.addEventListener("abort", onAborted);
+	});
+}
+/**
+* @internal
+* @returns the parsed value or undefined if the parsed value is invalid.
+*/
+function parseHeaderValueAsNumber(response, headerName) {
+	const value = response.headers.get(headerName);
+	if (!value) return;
+	const valueAsNum = Number(value);
+	if (Number.isNaN(valueAsNum)) return;
+	return valueAsNum;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/retryStrategies/throttlingRetryStrategy.js
+/**
+* The header that comes back from services representing
+* the amount of time (minimum) to wait to retry (in seconds or timestamp after which we can retry).
+*/
+const RetryAfterHeader = "Retry-After";
+/**
+* The headers that come back from services representing
+* the amount of time (minimum) to wait to retry.
+*
+* "retry-after-ms", "x-ms-retry-after-ms" : milliseconds
+* "Retry-After" : seconds or timestamp
+*/
+const AllRetryAfterHeaders = [
+	"retry-after-ms",
+	"x-ms-retry-after-ms",
+	RetryAfterHeader
+];
+/**
+* A response is a throttling retry response if it has a throttling status code (429 or 503),
+* as long as one of the [ "Retry-After" or "retry-after-ms" or "x-ms-retry-after-ms" ] headers has a valid value.
+*
+* Returns the `retryAfterInMs` value if the response is a throttling retry response.
+* If not throttling retry response, returns `undefined`.
+*
+* @internal
+*/
+function getRetryAfterInMs(response) {
+	if (!(response && [429, 503].includes(response.status))) return void 0;
+	try {
+		for (const header of AllRetryAfterHeaders) {
+			const retryAfterValue = parseHeaderValueAsNumber(response, header);
+			if (retryAfterValue === 0 || retryAfterValue) return retryAfterValue * (header === RetryAfterHeader ? 1e3 : 1);
+		}
+		const retryAfterHeader = response.headers.get(RetryAfterHeader);
+		if (!retryAfterHeader) return;
+		const diff = Date.parse(retryAfterHeader) - Date.now();
+		return Number.isFinite(diff) ? Math.max(0, diff) : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* A response is a retry response if it has a throttling status code (429 or 503),
+* as long as one of the [ "Retry-After" or "retry-after-ms" or "x-ms-retry-after-ms" ] headers has a valid value.
+*/
+function isThrottlingRetryResponse(response) {
+	return Number.isFinite(getRetryAfterInMs(response));
+}
+function throttlingRetryStrategy() {
+	return {
+		name: "throttlingRetryStrategy",
+		retry({ response }) {
+			const retryAfterInMs = getRetryAfterInMs(response);
+			if (!Number.isFinite(retryAfterInMs)) return { skipStrategy: true };
+			return { retryAfterInMs };
+		}
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/retryStrategies/exponentialRetryStrategy.js
+const DEFAULT_CLIENT_RETRY_INTERVAL = 1e3;
+const DEFAULT_CLIENT_MAX_RETRY_INTERVAL = 1e3 * 64;
+/**
+* A retry strategy that retries with an exponentially increasing delay in these two cases:
+* - When there are errors in the underlying transport layer (e.g. DNS lookup failures).
+* - Or otherwise if the outgoing request fails (408, greater or equal than 500, except for 501 and 505).
+*/
+function exponentialRetryStrategy(options = {}) {
+	const retryInterval = options.retryDelayInMs ?? DEFAULT_CLIENT_RETRY_INTERVAL;
+	const maxRetryInterval = options.maxRetryDelayInMs ?? DEFAULT_CLIENT_MAX_RETRY_INTERVAL;
+	return {
+		name: "exponentialRetryStrategy",
+		retry({ retryCount, response, responseError }) {
+			const matchedSystemError = isSystemError(responseError);
+			const ignoreSystemErrors = matchedSystemError && options.ignoreSystemErrors;
+			const isExponential = isExponentialRetryResponse(response);
+			const ignoreExponentialResponse = isExponential && options.ignoreHttpStatusCodes;
+			if (response && (isThrottlingRetryResponse(response) || !isExponential) || ignoreExponentialResponse || ignoreSystemErrors) return { skipStrategy: true };
+			if (responseError && !matchedSystemError && !isExponential) return { errorToThrow: responseError };
+			return calculateRetryDelay$1(retryCount, {
+				retryDelayInMs: retryInterval,
+				maxRetryDelayInMs: maxRetryInterval
+			});
+		}
+	};
+}
+/**
+* A response is a retry response if it has status codes:
+* - 408, or
+* - Greater or equal than 500, except for 501 and 505.
+*/
+function isExponentialRetryResponse(response) {
+	return Boolean(response && response.status !== void 0 && (response.status >= 500 || response.status === 408) && response.status !== 501 && response.status !== 505);
+}
+/**
+* Determines whether an error from a pipeline response was triggered in the network layer.
+*/
+function isSystemError(err) {
+	if (!err) return false;
+	return err.code === "ETIMEDOUT" || err.code === "ESOCKETTIMEDOUT" || err.code === "ECONNREFUSED" || err.code === "ECONNRESET" || err.code === "ENOENT" || err.code === "ENOTFOUND";
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/policies/retryPolicy.js
+const retryPolicyLogger = createClientLogger$1("ts-http-runtime retryPolicy");
+/**
+* The programmatic identifier of the retryPolicy.
+*/
+const retryPolicyName = "retryPolicy";
+/**
+* retryPolicy is a generic policy to enable retrying requests when certain conditions are met
+*/
+function retryPolicy(strategies, options = { maxRetries: 3 }) {
+	const logger = options.logger || retryPolicyLogger;
+	return {
+		name: retryPolicyName,
+		async sendRequest(request, next) {
+			let response;
+			let responseError;
+			let retryCount = -1;
+			retryRequest: while (true) {
+				retryCount += 1;
+				response = void 0;
+				responseError = void 0;
+				try {
+					logger.info(`Retry ${retryCount}: Attempting to send request`, request.requestId);
+					response = await next(request);
+					logger.info(`Retry ${retryCount}: Received a response from request`, request.requestId);
+				} catch (e) {
+					logger.error(`Retry ${retryCount}: Received an error from request`, request.requestId);
+					responseError = e;
+					if (!e || responseError.name !== "RestError") throw e;
+					response = responseError.response;
+				}
+				if (request.abortSignal?.aborted) {
+					logger.error(`Retry ${retryCount}: Request aborted.`);
+					throw new AbortError();
+				}
+				if (retryCount >= (options.maxRetries ?? 3)) {
+					logger.info(`Retry ${retryCount}: Maximum retries reached. Returning the last received response, or throwing the last received error.`);
+					if (responseError) throw responseError;
+					else if (response) return response;
+					else throw new Error("Maximum retries reached with no response or error to throw");
+				}
+				logger.info(`Retry ${retryCount}: Processing ${strategies.length} retry strategies.`);
+				strategiesLoop: for (const strategy of strategies) {
+					const strategyLogger = strategy.logger || logger;
+					strategyLogger.info(`Retry ${retryCount}: Processing retry strategy ${strategy.name}.`);
+					const modifiers = strategy.retry({
+						retryCount,
+						response,
+						responseError
+					});
+					if (modifiers.skipStrategy) {
+						strategyLogger.info(`Retry ${retryCount}: Skipped.`);
+						continue strategiesLoop;
+					}
+					const { errorToThrow, retryAfterInMs, redirectTo } = modifiers;
+					if (errorToThrow) {
+						strategyLogger.error(`Retry ${retryCount}: Retry strategy ${strategy.name} throws error:`, errorToThrow);
+						throw errorToThrow;
+					}
+					if (retryAfterInMs || retryAfterInMs === 0) {
+						strategyLogger.info(`Retry ${retryCount}: Retry strategy ${strategy.name} retries after ${retryAfterInMs}`);
+						await delay(retryAfterInMs, void 0, { abortSignal: request.abortSignal });
+						continue retryRequest;
+					}
+					if (redirectTo) {
+						strategyLogger.info(`Retry ${retryCount}: Retry strategy ${strategy.name} redirects to ${redirectTo}`);
+						request.url = redirectTo;
+						continue retryRequest;
+					}
+				}
+				if (responseError) {
+					logger.info(`None of the retry strategies could work with the received error. Throwing it.`);
+					throw responseError;
+				}
+				if (response) {
+					logger.info(`None of the retry strategies could work with the received response. Returning it.`);
+					return response;
+				}
+			}
+		}
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/policies/defaultRetryPolicy.js
+/**
+* Name of the {@link defaultRetryPolicy}
+*/
+const defaultRetryPolicyName = "defaultRetryPolicy";
+/**
+* A policy that retries according to three strategies:
+* - When the server sends a 429 response with a Retry-After header.
+* - When there are errors in the underlying transport layer (e.g. DNS lookup failures).
+* - Or otherwise if the outgoing request fails, it will retry with an exponentially increasing delay.
+*/
+function defaultRetryPolicy$1(options = {}) {
+	return {
+		name: defaultRetryPolicyName,
+		sendRequest: retryPolicy([throttlingRetryStrategy(), exponentialRetryStrategy(options)], { maxRetries: options.maxRetries ?? 3 }).sendRequest
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/policies/formDataPolicy.js
+/**
+* The programmatic identifier of the formDataPolicy.
+*/
+const formDataPolicyName = "formDataPolicy";
+function formDataToFormDataMap(formData) {
+	const formDataMap = {};
+	for (const [key, value] of formData.entries()) {
+		formDataMap[key] ??= [];
+		formDataMap[key].push(value);
+	}
+	return formDataMap;
+}
+/**
+* A policy that encodes FormData on the request into the body.
+*/
+function formDataPolicy$1() {
+	return {
+		name: formDataPolicyName,
+		async sendRequest(request, next) {
+			if (isNodeLike$1 && typeof FormData !== "undefined" && request.body instanceof FormData) {
+				request.formData = formDataToFormDataMap(request.body);
+				request.body = void 0;
+			}
+			if (request.formData) {
+				const contentType = request.headers.get("Content-Type");
+				if (contentType && contentType.indexOf("application/x-www-form-urlencoded") !== -1) request.body = wwwFormUrlEncode(request.formData);
+				else await prepareFormData(request.formData, request);
+				request.formData = void 0;
+			}
+			return next(request);
+		}
+	};
+}
+function wwwFormUrlEncode(formData) {
+	const urlSearchParams = new URLSearchParams();
+	for (const [key, value] of Object.entries(formData)) if (Array.isArray(value)) for (const subValue of value) urlSearchParams.append(key, subValue.toString());
+	else urlSearchParams.append(key, value.toString());
+	return urlSearchParams.toString();
+}
+async function prepareFormData(formData, request) {
+	const contentType = request.headers.get("Content-Type");
+	if (contentType && !contentType.startsWith("multipart/form-data")) return;
+	request.headers.set("Content-Type", contentType ?? "multipart/form-data");
+	const parts = [];
+	for (const [fieldName, values] of Object.entries(formData)) for (const value of Array.isArray(values) ? values : [values]) if (typeof value === "string") parts.push({
+		headers: createHttpHeaders({ "Content-Disposition": `form-data; name="${fieldName}"` }),
+		body: stringToUint8Array$1(value, "utf-8")
+	});
+	else if (value === void 0 || value === null || typeof value !== "object") throw new Error(`Unexpected value for key ${fieldName}: ${value}. Value should be serialized to string first.`);
+	else {
+		const fileName = value.name || "blob";
+		const headers = createHttpHeaders();
+		headers.set("Content-Disposition", `form-data; name="${fieldName}"; filename="${fileName}"`);
+		headers.set("Content-Type", value.type || "application/octet-stream");
+		parts.push({
+			headers,
+			body: value
+		});
+	}
+	request.multipartBody = { parts };
+}
+//#endregion
+//#region ../../node_modules/.pnpm/http-proxy-agent@7.0.2/node_modules/http-proxy-agent/dist/index.js
+var require_dist = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+		if (k2 === void 0) k2 = k;
+		var desc = Object.getOwnPropertyDescriptor(m, k);
+		if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) desc = {
+			enumerable: true,
+			get: function() {
+				return m[k];
+			}
+		};
+		Object.defineProperty(o, k2, desc);
+	}) : (function(o, m, k, k2) {
+		if (k2 === void 0) k2 = k;
+		o[k2] = m[k];
+	}));
+	var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
+		Object.defineProperty(o, "default", {
+			enumerable: true,
+			value: v
+		});
+	}) : function(o, v) {
+		o["default"] = v;
+	});
+	var __importStar = exports && exports.__importStar || function(mod) {
+		if (mod && mod.__esModule) return mod;
+		var result = {};
+		if (mod != null) {
+			for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+		}
+		__setModuleDefault(result, mod);
+		return result;
+	};
+	var __importDefault = exports && exports.__importDefault || function(mod) {
+		return mod && mod.__esModule ? mod : { "default": mod };
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.HttpProxyAgent = void 0;
+	const net = __importStar(__require("net"));
+	const tls = __importStar(__require("tls"));
+	const debug_1 = __importDefault(require_src());
+	const events_1 = __require("events");
+	const agent_base_1 = require_dist$1();
+	const url_1 = __require("url");
+	const debug = (0, debug_1.default)("http-proxy-agent");
+	/**
+	* The `HttpProxyAgent` implements an HTTP Agent subclass that connects
+	* to the specified "HTTP proxy server" in order to proxy HTTP requests.
+	*/
+	var HttpProxyAgent = class extends agent_base_1.Agent {
+		constructor(proxy, opts) {
+			super(opts);
+			this.proxy = typeof proxy === "string" ? new url_1.URL(proxy) : proxy;
+			this.proxyHeaders = opts?.headers ?? {};
+			debug("Creating new HttpProxyAgent instance: %o", this.proxy.href);
+			const host = (this.proxy.hostname || this.proxy.host).replace(/^\[|\]$/g, "");
+			const port = this.proxy.port ? parseInt(this.proxy.port, 10) : this.proxy.protocol === "https:" ? 443 : 80;
+			this.connectOpts = {
+				...opts ? omit(opts, "headers") : null,
+				host,
+				port
+			};
+		}
+		addRequest(req, opts) {
+			req._header = null;
+			this.setRequestProps(req, opts);
+			super.addRequest(req, opts);
+		}
+		setRequestProps(req, opts) {
+			const { proxy } = this;
+			const base = `${opts.secureEndpoint ? "https:" : "http:"}//${req.getHeader("host") || "localhost"}`;
+			const url = new url_1.URL(req.path, base);
+			if (opts.port !== 80) url.port = String(opts.port);
+			req.path = String(url);
+			const headers = typeof this.proxyHeaders === "function" ? this.proxyHeaders() : { ...this.proxyHeaders };
+			if (proxy.username || proxy.password) {
+				const auth = `${decodeURIComponent(proxy.username)}:${decodeURIComponent(proxy.password)}`;
+				headers["Proxy-Authorization"] = `Basic ${Buffer.from(auth).toString("base64")}`;
+			}
+			if (!headers["Proxy-Connection"]) headers["Proxy-Connection"] = this.keepAlive ? "Keep-Alive" : "close";
+			for (const name of Object.keys(headers)) {
+				const value = headers[name];
+				if (value) req.setHeader(name, value);
+			}
+		}
+		async connect(req, opts) {
+			req._header = null;
+			if (!req.path.includes("://")) this.setRequestProps(req, opts);
+			let first;
+			let endOfHeaders;
+			debug("Regenerating stored HTTP header string for request");
+			req._implicitHeader();
+			if (req.outputData && req.outputData.length > 0) {
+				debug("Patching connection write() output buffer with updated header");
+				first = req.outputData[0].data;
+				endOfHeaders = first.indexOf("\r\n\r\n") + 4;
+				req.outputData[0].data = req._header + first.substring(endOfHeaders);
+				debug("Output buffer: %o", req.outputData[0].data);
+			}
+			let socket;
+			if (this.proxy.protocol === "https:") {
+				debug("Creating `tls.Socket`: %o", this.connectOpts);
+				socket = tls.connect(this.connectOpts);
+			} else {
+				debug("Creating `net.Socket`: %o", this.connectOpts);
+				socket = net.connect(this.connectOpts);
+			}
+			await (0, events_1.once)(socket, "connect");
+			return socket;
+		}
+	};
+	HttpProxyAgent.protocols = ["http", "https"];
+	exports.HttpProxyAgent = HttpProxyAgent;
+	function omit(obj, ...keys) {
+		const ret = {};
+		let key;
+		for (key in obj) if (!keys.includes(key)) ret[key] = obj[key];
+		return ret;
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/policies/proxyPolicy.js
+var import_dist = require_dist$2();
+var import_dist$1 = require_dist();
+const HTTPS_PROXY = "HTTPS_PROXY";
+const HTTP_PROXY = "HTTP_PROXY";
+const ALL_PROXY = "ALL_PROXY";
+const NO_PROXY = "NO_PROXY";
+/**
+* The programmatic identifier of the proxyPolicy.
+*/
+const proxyPolicyName = "proxyPolicy";
+/**
+* Stores the patterns specified in NO_PROXY environment variable.
+* @internal
+*/
+const globalNoProxyList = [];
+let noProxyListLoaded = false;
+/** A cache of whether a host should bypass the proxy. */
+const globalBypassedMap = /* @__PURE__ */ new Map();
+function getEnvironmentValue(name) {
+	if (process.env[name]) return process.env[name];
+	else if (process.env[name.toLowerCase()]) return process.env[name.toLowerCase()];
+}
+function loadEnvironmentProxyValue() {
+	if (!process) return;
+	const httpsProxy = getEnvironmentValue(HTTPS_PROXY);
+	const allProxy = getEnvironmentValue(ALL_PROXY);
+	const httpProxy = getEnvironmentValue(HTTP_PROXY);
+	return httpsProxy || allProxy || httpProxy;
+}
+/**
+* Check whether the host of a given `uri` matches any pattern in the no proxy list.
+* If there's a match, any request sent to the same host shouldn't have the proxy settings set.
+* This implementation is a port of https://github.com/Azure/azure-sdk-for-net/blob/8cca811371159e527159c7eb65602477898683e2/sdk/core/Azure.Core/src/Pipeline/Internal/HttpEnvironmentProxy.cs#L210
+*/
+function isBypassed(uri, noProxyList, bypassedMap) {
+	if (noProxyList.length === 0) return false;
+	const host = new URL(uri).hostname;
+	if (bypassedMap?.has(host)) return bypassedMap.get(host);
+	let isBypassedFlag = false;
+	for (const pattern of noProxyList) if (pattern[0] === ".") {
+		if (host.endsWith(pattern)) isBypassedFlag = true;
+		else if (host.length === pattern.length - 1 && host === pattern.slice(1)) isBypassedFlag = true;
+	} else if (host === pattern) isBypassedFlag = true;
+	bypassedMap?.set(host, isBypassedFlag);
+	return isBypassedFlag;
+}
+function loadNoProxy() {
+	const noProxy = getEnvironmentValue(NO_PROXY);
+	noProxyListLoaded = true;
+	if (noProxy) return noProxy.split(",").map((item) => item.trim()).filter((item) => item.length);
+	return [];
+}
+/**
+* This method attempts to parse a proxy URL from the environment
+* variables `HTTPS_PROXY` or `HTTP_PROXY`.
+*/
+function getDefaultProxySettingsInternal() {
+	const envProxy = loadEnvironmentProxyValue();
+	return envProxy ? new URL(envProxy) : void 0;
+}
+function getUrlFromProxySettings(settings) {
+	let parsedProxyUrl;
+	try {
+		parsedProxyUrl = new URL(settings.host);
+	} catch {
+		throw new Error(`Expecting a valid host string in proxy settings, but found "${settings.host}".`);
+	}
+	parsedProxyUrl.port = String(settings.port);
+	if (settings.username) parsedProxyUrl.username = settings.username;
+	if (settings.password) parsedProxyUrl.password = settings.password;
+	return parsedProxyUrl;
+}
+function setProxyAgentOnRequest(request, cachedAgents, proxyUrl) {
+	if (request.agent) return;
+	const isInsecure = new URL(request.url).protocol !== "https:";
+	if (request.tlsSettings) logger$1.warning("TLS settings are not supported in combination with custom Proxy, certificates provided to the client will be ignored.");
+	const headers = request.headers.toJSON();
+	if (isInsecure) {
+		if (!cachedAgents.httpProxyAgent) cachedAgents.httpProxyAgent = new import_dist$1.HttpProxyAgent(proxyUrl, { headers });
+		request.agent = cachedAgents.httpProxyAgent;
+	} else {
+		if (!cachedAgents.httpsProxyAgent) cachedAgents.httpsProxyAgent = new import_dist.HttpsProxyAgent(proxyUrl, { headers });
+		request.agent = cachedAgents.httpsProxyAgent;
+	}
+}
+/**
+* A policy that allows one to apply proxy settings to all requests.
+* If not passed static settings, they will be retrieved from the HTTPS_PROXY
+* or HTTP_PROXY environment variables.
+* @param proxySettings - ProxySettings to use on each request.
+* @param options - additional settings, for example, custom NO_PROXY patterns
+*/
+function proxyPolicy$1(proxySettings, options) {
+	if (!noProxyListLoaded) globalNoProxyList.push(...loadNoProxy());
+	const defaultProxy = proxySettings ? getUrlFromProxySettings(proxySettings) : getDefaultProxySettingsInternal();
+	const cachedAgents = {};
+	return {
+		name: proxyPolicyName,
+		async sendRequest(request, next) {
+			if (!request.proxySettings && defaultProxy && !isBypassed(request.url, options?.customNoProxyList ?? globalNoProxyList, options?.customNoProxyList ? void 0 : globalBypassedMap)) setProxyAgentOnRequest(request, cachedAgents, defaultProxy);
+			else if (request.proxySettings) setProxyAgentOnRequest(request, cachedAgents, getUrlFromProxySettings(request.proxySettings));
+			return next(request);
+		}
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/policies/agentPolicy.js
+/**
+* Name of the Agent Policy
+*/
+const agentPolicyName = "agentPolicy";
+/**
+* Gets a pipeline policy that sets http.agent
+*/
+function agentPolicy$1(agent) {
+	return {
+		name: agentPolicyName,
+		sendRequest: async (req, next) => {
+			if (!req.agent) req.agent = agent;
+			return next(req);
+		}
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/policies/tlsPolicy.js
+/**
+* Name of the TLS Policy
+*/
+const tlsPolicyName = "tlsPolicy";
+/**
+* Gets a pipeline policy that adds the client certificate to the HttpClient agent for authentication.
+*/
+function tlsPolicy$1(tlsSettings) {
+	return {
+		name: tlsPolicyName,
+		sendRequest: async (req, next) => {
+			if (!req.tlsSettings) req.tlsSettings = tlsSettings;
+			return next(req);
+		}
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/util/typeGuards.js
+function isNodeReadableStream(x) {
+	return Boolean(x && typeof x["pipe"] === "function");
+}
+function isWebReadableStream(x) {
+	return Boolean(x && typeof x.getReader === "function" && typeof x.tee === "function");
+}
+function isBinaryBody(body) {
+	return body !== void 0 && (body instanceof Uint8Array || isReadableStream(body) || typeof body === "function" || body instanceof Blob);
+}
+function isReadableStream(x) {
+	return isNodeReadableStream(x) || isWebReadableStream(x);
+}
+function isBlob(x) {
+	return typeof x.stream === "function";
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/util/concat.js
+async function* streamAsyncIterator() {
+	const reader = this.getReader();
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) return;
+			yield value;
+		}
+	} finally {
+		reader.releaseLock();
+	}
+}
+function makeAsyncIterable(webStream) {
+	if (!webStream[Symbol.asyncIterator]) webStream[Symbol.asyncIterator] = streamAsyncIterator.bind(webStream);
+	if (!webStream.values) webStream.values = streamAsyncIterator.bind(webStream);
+}
+function ensureNodeStream(stream) {
+	if (stream instanceof ReadableStream) {
+		makeAsyncIterable(stream);
+		return Readable.fromWeb(stream);
+	} else return stream;
+}
+function toStream(source) {
+	if (source instanceof Uint8Array) return Readable.from(Buffer.from(source));
+	else if (isBlob(source)) return ensureNodeStream(source.stream());
+	else return ensureNodeStream(source);
+}
+/**
+* Utility function that concatenates a set of binary inputs into one combined output.
+*
+* @param sources - array of sources for the concatenation
+* @returns - in Node, a (() =\> NodeJS.ReadableStream) which, when read, produces a concatenation of all the inputs.
+*           In browser, returns a `Blob` representing all the concatenated inputs.
+*
+* @internal
+*/
+async function concat(sources) {
+	return function() {
+		const streams = sources.map((x) => typeof x === "function" ? x() : x).map(toStream);
+		return Readable.from((async function* () {
+			for (const stream of streams) for await (const chunk of stream) yield chunk;
+		})());
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/policies/multipartPolicy.js
+function generateBoundary() {
+	return `----AzSDKFormBoundary${randomUUID()}`;
+}
+function encodeHeaders(headers) {
+	let result = "";
+	for (const [key, value] of headers) result += `${key}: ${value}\r\n`;
+	return result;
+}
+function getLength(source) {
+	if (source instanceof Uint8Array) return source.byteLength;
+	else if (isBlob(source)) return source.size === -1 ? void 0 : source.size;
+	else return;
+}
+function getTotalLength(sources) {
+	let total = 0;
+	for (const source of sources) {
+		const partLength = getLength(source);
+		if (partLength === void 0) return;
+		else total += partLength;
+	}
+	return total;
+}
+async function buildRequestBody(request, parts, boundary) {
+	const sources = [
+		stringToUint8Array$1(`--${boundary}`, "utf-8"),
+		...parts.flatMap((part) => [
+			stringToUint8Array$1("\r\n", "utf-8"),
+			stringToUint8Array$1(encodeHeaders(part.headers), "utf-8"),
+			stringToUint8Array$1("\r\n", "utf-8"),
+			part.body,
+			stringToUint8Array$1(`\r\n--${boundary}`, "utf-8")
+		]),
+		stringToUint8Array$1("--\r\n\r\n", "utf-8")
+	];
+	const contentLength = getTotalLength(sources);
+	if (contentLength) request.headers.set("Content-Length", contentLength);
+	request.body = await concat(sources);
+}
+/**
+* Name of multipart policy
+*/
+const multipartPolicyName$1 = "multipartPolicy";
+const maxBoundaryLength = 70;
+const validBoundaryCharacters = /* @__PURE__ */ new Set(`abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'()+,-./:=?`);
+function assertValidBoundary(boundary) {
+	if (boundary.length > maxBoundaryLength) throw new Error(`Multipart boundary "${boundary}" exceeds maximum length of 70 characters`);
+	if (Array.from(boundary).some((x) => !validBoundaryCharacters.has(x))) throw new Error(`Multipart boundary "${boundary}" contains invalid characters`);
+}
+/**
+* Pipeline policy for multipart requests
+*/
+function multipartPolicy$1() {
+	return {
+		name: multipartPolicyName$1,
+		async sendRequest(request, next) {
+			if (!request.multipartBody) return next(request);
+			if (request.body) throw new Error("multipartBody and regular body cannot be set at the same time");
+			let boundary = request.multipartBody.boundary;
+			const contentTypeHeader = request.headers.get("Content-Type") ?? "multipart/mixed";
+			const parsedHeader = contentTypeHeader.match(/^(multipart\/[^ ;]+)(?:; *boundary=(.+))?$/);
+			if (!parsedHeader) throw new Error(`Got multipart request body, but content-type header was not multipart: ${contentTypeHeader}`);
+			const [, contentType, parsedBoundary] = parsedHeader;
+			if (parsedBoundary && boundary && parsedBoundary !== boundary) throw new Error(`Multipart boundary was specified as ${parsedBoundary} in the header, but got ${boundary} in the request body`);
+			boundary ??= parsedBoundary;
+			if (boundary) assertValidBoundary(boundary);
+			else boundary = generateBoundary();
+			request.headers.set("Content-Type", `${contentType}; boundary=${boundary}`);
+			await buildRequestBody(request, request.multipartBody.parts, boundary);
+			request.multipartBody = void 0;
+			return next(request);
+		}
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+core-rest-pipeline@1.22.2/node_modules/@azure/core-rest-pipeline/dist/esm/pipeline.js
+/**
+* Creates a totally empty pipeline.
+* Useful for testing or creating a custom one.
+*/
+function createEmptyPipeline() {
+	return createEmptyPipeline$1();
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+core-rest-pipeline@1.22.2/node_modules/@azure/core-rest-pipeline/dist/esm/log.js
+const logger = createClientLogger("core-rest-pipeline");
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+core-rest-pipeline@1.22.2/node_modules/@azure/core-rest-pipeline/dist/esm/policies/logPolicy.js
+/**
+* A policy that logs all requests and responses.
+* @param options - Options to configure logPolicy.
+*/
+function logPolicy(options = {}) {
+	return logPolicy$1({
+		logger: logger.info,
+		...options
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+core-rest-pipeline@1.22.2/node_modules/@azure/core-rest-pipeline/dist/esm/policies/redirectPolicy.js
+/**
+* A policy to follow Location headers from the server in order
+* to support server-side redirection.
+* In the browser, this policy is not used.
+* @param options - Options to control policy behavior.
+*/
+function redirectPolicy(options = {}) {
+	return redirectPolicy$1(options);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+core-rest-pipeline@1.22.2/node_modules/@azure/core-rest-pipeline/dist/esm/util/userAgentPlatform.js
+/**
+* @internal
+*/
+function getHeaderName() {
+	return "User-Agent";
+}
+/**
+* @internal
+*/
+async function setPlatformSpecificData(map) {
+	if (process$1 && process$1.versions) {
+		const osInfo = `${os.type()} ${os.release()}; ${os.arch()}`;
+		const versions = process$1.versions;
+		if (versions.bun) map.set("Bun", `${versions.bun} (${osInfo})`);
+		else if (versions.deno) map.set("Deno", `${versions.deno} (${osInfo})`);
+		else if (versions.node) map.set("Node", `${versions.node} (${osInfo})`);
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+core-rest-pipeline@1.22.2/node_modules/@azure/core-rest-pipeline/dist/esm/constants.js
+const SDK_VERSION = "1.22.2";
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+core-rest-pipeline@1.22.2/node_modules/@azure/core-rest-pipeline/dist/esm/util/userAgent.js
+function getUserAgentString(telemetryInfo) {
+	const parts = [];
+	for (const [key, value] of telemetryInfo) {
+		const token = value ? `${key}/${value}` : key;
+		parts.push(token);
+	}
+	return parts.join(" ");
+}
+/**
+* @internal
+*/
+function getUserAgentHeaderName() {
+	return getHeaderName();
+}
+/**
+* @internal
+*/
+async function getUserAgentValue(prefix) {
+	const runtimeInfo = /* @__PURE__ */ new Map();
+	runtimeInfo.set("core-rest-pipeline", SDK_VERSION);
+	await setPlatformSpecificData(runtimeInfo);
+	const defaultAgent = getUserAgentString(runtimeInfo);
+	return prefix ? `${prefix} ${defaultAgent}` : defaultAgent;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+core-rest-pipeline@1.22.2/node_modules/@azure/core-rest-pipeline/dist/esm/policies/userAgentPolicy.js
+const UserAgentHeaderName = getUserAgentHeaderName();
+/**
+* The programmatic identifier of the userAgentPolicy.
+*/
+const userAgentPolicyName = "userAgentPolicy";
+/**
+* A policy that sets the User-Agent header (or equivalent) to reflect
+* the library version.
+* @param options - Options to customize the user agent value.
+*/
+function userAgentPolicy(options = {}) {
+	const userAgentValue = getUserAgentValue(options.userAgentPrefix);
+	return {
+		name: userAgentPolicyName,
+		async sendRequest(request, next) {
+			if (!request.headers.has(UserAgentHeaderName)) request.headers.set(UserAgentHeaderName, await userAgentValue);
+			return next(request);
+		}
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+core-rest-pipeline@1.22.2/node_modules/@azure/core-rest-pipeline/dist/esm/util/file.js
+/**
+* Private symbol used as key on objects created using createFile containing the
+* original source of the file object.
+*
+* This is used in Node to access the original Node stream without using Blob#stream, which
+* returns a web stream. This is done to avoid a couple of bugs to do with Blob#stream and
+* Readable#to/fromWeb in Node versions we support:
+* - https://github.com/nodejs/node/issues/42694 (fixed in Node 18.14)
+* - https://github.com/nodejs/node/issues/48916 (fixed in Node 20.6)
+*
+* Once these versions are no longer supported, we may be able to stop doing this.
+*
+* @internal
+*/
+const rawContent = Symbol("rawContent");
+/**
+* Type guard to check if a given object is a blob-like object with a raw content property.
+*/
+function hasRawContent(x) {
+	return typeof x[rawContent] === "function";
+}
+/**
+* Extract the raw content from a given blob-like object. If the input was created using createFile
+* or createFileFromStream, the exact content passed into createFile/createFileFromStream will be used.
+* For true instances of Blob and File, returns the actual blob.
+*
+* @internal
+*/
+function getRawContent(blob) {
+	if (hasRawContent(blob)) return blob[rawContent]();
+	else return blob;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+core-rest-pipeline@1.22.2/node_modules/@azure/core-rest-pipeline/dist/esm/policies/multipartPolicy.js
+/**
+* Name of multipart policy
+*/
+const multipartPolicyName = multipartPolicyName$1;
+/**
+* Pipeline policy for multipart requests
+*/
+function multipartPolicy() {
+	const tspPolicy = multipartPolicy$1();
+	return {
+		name: multipartPolicyName,
+		sendRequest: async (request, next) => {
+			if (request.multipartBody) {
+				for (const part of request.multipartBody.parts) if (hasRawContent(part.body)) part.body = getRawContent(part.body);
+			}
+			return tspPolicy.sendRequest(request, next);
+		}
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+core-rest-pipeline@1.22.2/node_modules/@azure/core-rest-pipeline/dist/esm/policies/decompressResponsePolicy.js
+/**
+* A policy to enable response decompression according to Accept-Encoding header
+* https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept-Encoding
+*/
+function decompressResponsePolicy() {
+	return decompressResponsePolicy$1();
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+core-rest-pipeline@1.22.2/node_modules/@azure/core-rest-pipeline/dist/esm/policies/defaultRetryPolicy.js
+/**
+* A policy that retries according to three strategies:
+* - When the server sends a 429 response with a Retry-After header.
+* - When there are errors in the underlying transport layer (e.g. DNS lookup failures).
+* - Or otherwise if the outgoing request fails, it will retry with an exponentially increasing delay.
+*/
+function defaultRetryPolicy(options = {}) {
+	return defaultRetryPolicy$1(options);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+core-rest-pipeline@1.22.2/node_modules/@azure/core-rest-pipeline/dist/esm/policies/formDataPolicy.js
+/**
+* A policy that encodes FormData on the request into the body.
+*/
+function formDataPolicy() {
+	return formDataPolicy$1();
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+core-rest-pipeline@1.22.2/node_modules/@azure/core-rest-pipeline/dist/esm/policies/proxyPolicy.js
+/**
+* A policy that allows one to apply proxy settings to all requests.
+* If not passed static settings, they will be retrieved from the HTTPS_PROXY
+* or HTTP_PROXY environment variables.
+* @param proxySettings - ProxySettings to use on each request.
+* @param options - additional settings, for example, custom NO_PROXY patterns
+*/
+function proxyPolicy(proxySettings, options) {
+	return proxyPolicy$1(proxySettings, options);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+core-rest-pipeline@1.22.2/node_modules/@azure/core-rest-pipeline/dist/esm/policies/setClientRequestIdPolicy.js
+/**
+* The programmatic identifier of the setClientRequestIdPolicy.
+*/
+const setClientRequestIdPolicyName = "setClientRequestIdPolicy";
+/**
+* Each PipelineRequest gets a unique id upon creation.
+* This policy passes that unique id along via an HTTP header to enable better
+* telemetry and tracing.
+* @param requestIdHeaderName - The name of the header to pass the request ID to.
+*/
+function setClientRequestIdPolicy(requestIdHeaderName = "x-ms-client-request-id") {
+	return {
+		name: setClientRequestIdPolicyName,
+		async sendRequest(request, next) {
+			if (!request.headers.has(requestIdHeaderName)) request.headers.set(requestIdHeaderName, request.requestId);
+			return next(request);
+		}
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+core-rest-pipeline@1.22.2/node_modules/@azure/core-rest-pipeline/dist/esm/policies/agentPolicy.js
+/**
+* Gets a pipeline policy that sets http.agent
+*/
+function agentPolicy(agent) {
+	return agentPolicy$1(agent);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+core-rest-pipeline@1.22.2/node_modules/@azure/core-rest-pipeline/dist/esm/policies/tlsPolicy.js
+/**
+* Gets a pipeline policy that adds the client certificate to the HttpClient agent for authentication.
+*/
+function tlsPolicy(tlsSettings) {
+	return tlsPolicy$1(tlsSettings);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+core-rest-pipeline@1.22.2/node_modules/@azure/core-rest-pipeline/dist/esm/restError.js
+/**
+* A custom error type for failed pipeline requests.
+*/
+const RestError = RestError$1;
+/**
+* Typeguard for RestError
+* @param e - Something caught by a catch clause.
+*/
+function isRestError(e) {
+	return isRestError$1(e);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+core-rest-pipeline@1.22.2/node_modules/@azure/core-rest-pipeline/dist/esm/policies/tracingPolicy.js
+/**
+* The programmatic identifier of the tracingPolicy.
+*/
+const tracingPolicyName = "tracingPolicy";
+/**
+* A simple policy to create OpenTelemetry Spans for each request made by the pipeline
+* that has SpanOptions with a parent.
+* Requests made without a parent Span will not be recorded.
+* @param options - Options to configure the telemetry logged by the tracing policy.
+*/
+function tracingPolicy(options = {}) {
+	const userAgentPromise = getUserAgentValue(options.userAgentPrefix);
+	const sanitizer = new Sanitizer({ additionalAllowedQueryParameters: options.additionalAllowedQueryParameters });
+	const tracingClient = tryCreateTracingClient();
+	return {
+		name: tracingPolicyName,
+		async sendRequest(request, next) {
+			if (!tracingClient) return next(request);
+			const userAgent = await userAgentPromise;
+			const spanAttributes = {
+				"http.url": sanitizer.sanitizeUrl(request.url),
+				"http.method": request.method,
+				"http.user_agent": userAgent,
+				requestId: request.requestId
+			};
+			if (userAgent) spanAttributes["http.user_agent"] = userAgent;
+			const { span, tracingContext } = tryCreateSpan(tracingClient, request, spanAttributes) ?? {};
+			if (!span || !tracingContext) return next(request);
+			try {
+				const response = await tracingClient.withContext(tracingContext, next, request);
+				tryProcessResponse(span, response);
+				return response;
+			} catch (err) {
+				tryProcessError(span, err);
+				throw err;
+			}
+		}
+	};
+}
+function tryCreateTracingClient() {
+	try {
+		return createTracingClient({
+			namespace: "",
+			packageName: "@azure/core-rest-pipeline",
+			packageVersion: SDK_VERSION
+		});
+	} catch (e) {
+		logger.warning(`Error when creating the TracingClient: ${getErrorMessage(e)}`);
+		return;
+	}
+}
+function tryCreateSpan(tracingClient, request, spanAttributes) {
+	try {
+		const { span, updatedOptions } = tracingClient.startSpan(`HTTP ${request.method}`, { tracingOptions: request.tracingOptions }, {
+			spanKind: "client",
+			spanAttributes
+		});
+		if (!span.isRecording()) {
+			span.end();
+			return;
+		}
+		const headers = tracingClient.createRequestHeaders(updatedOptions.tracingOptions.tracingContext);
+		for (const [key, value] of Object.entries(headers)) request.headers.set(key, value);
+		return {
+			span,
+			tracingContext: updatedOptions.tracingOptions.tracingContext
+		};
+	} catch (e) {
+		logger.warning(`Skipping creating a tracing span due to an error: ${getErrorMessage(e)}`);
+		return;
+	}
+}
+function tryProcessError(span, error) {
+	try {
+		span.setStatus({
+			status: "error",
+			error: isError(error) ? error : void 0
+		});
+		if (isRestError(error) && error.statusCode) span.setAttribute("http.status_code", error.statusCode);
+		span.end();
+	} catch (e) {
+		logger.warning(`Skipping tracing span processing due to an error: ${getErrorMessage(e)}`);
+	}
+}
+function tryProcessResponse(span, response) {
+	try {
+		span.setAttribute("http.status_code", response.status);
+		const serviceRequestId = response.headers.get("x-ms-request-id");
+		if (serviceRequestId) span.setAttribute("serviceRequestId", serviceRequestId);
+		if (response.status >= 400) span.setStatus({ status: "error" });
+		span.end();
+	} catch (e) {
+		logger.warning(`Skipping tracing span processing due to an error: ${getErrorMessage(e)}`);
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+core-rest-pipeline@1.22.2/node_modules/@azure/core-rest-pipeline/dist/esm/util/wrapAbortSignal.js
+/**
+* Creates a native AbortSignal which reflects the state of the provided AbortSignalLike.
+* If the AbortSignalLike is already a native AbortSignal, it is returned as is.
+* @param abortSignalLike - The AbortSignalLike to wrap.
+* @returns - An object containing the native AbortSignal and an optional cleanup function. The cleanup function should be called when the AbortSignal is no longer needed.
+*/
+function wrapAbortSignalLike(abortSignalLike) {
+	if (abortSignalLike instanceof AbortSignal) return { abortSignal: abortSignalLike };
+	if (abortSignalLike.aborted) return { abortSignal: AbortSignal.abort(abortSignalLike.reason) };
+	const controller = new AbortController();
+	let needsCleanup = true;
+	function cleanup() {
+		if (needsCleanup) {
+			abortSignalLike.removeEventListener("abort", listener);
+			needsCleanup = false;
+		}
+	}
+	function listener() {
+		controller.abort(abortSignalLike.reason);
+		cleanup();
+	}
+	abortSignalLike.addEventListener("abort", listener);
+	return {
+		abortSignal: controller.signal,
+		cleanup
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+core-rest-pipeline@1.22.2/node_modules/@azure/core-rest-pipeline/dist/esm/policies/wrapAbortSignalLikePolicy.js
+const wrapAbortSignalLikePolicyName = "wrapAbortSignalLikePolicy";
+/**
+* Policy that ensure that any AbortSignalLike is wrapped in a native AbortSignal for processing by the pipeline.
+* Since the ts-http-runtime expects a native AbortSignal, this policy is used to ensure that any AbortSignalLike is wrapped in a native AbortSignal.
+*
+* @returns - created policy
+*/
+function wrapAbortSignalLikePolicy() {
+	return {
+		name: wrapAbortSignalLikePolicyName,
+		sendRequest: async (request, next) => {
+			if (!request.abortSignal) return next(request);
+			const { abortSignal, cleanup } = wrapAbortSignalLike(request.abortSignal);
+			request.abortSignal = abortSignal;
+			try {
+				return await next(request);
+			} finally {
+				cleanup?.();
+			}
+		}
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+core-rest-pipeline@1.22.2/node_modules/@azure/core-rest-pipeline/dist/esm/createPipelineFromOptions.js
+/**
+* Create a new pipeline with a default set of customizable policies.
+* @param options - Options to configure a custom pipeline.
+*/
+function createPipelineFromOptions(options) {
+	const pipeline = createEmptyPipeline();
+	if (isNodeLike) {
+		if (options.agent) pipeline.addPolicy(agentPolicy(options.agent));
+		if (options.tlsOptions) pipeline.addPolicy(tlsPolicy(options.tlsOptions));
+		pipeline.addPolicy(proxyPolicy(options.proxyOptions));
+		pipeline.addPolicy(decompressResponsePolicy());
+	}
+	pipeline.addPolicy(wrapAbortSignalLikePolicy());
+	pipeline.addPolicy(formDataPolicy(), { beforePolicies: [multipartPolicyName] });
+	pipeline.addPolicy(userAgentPolicy(options.userAgentOptions));
+	pipeline.addPolicy(setClientRequestIdPolicy(options.telemetryOptions?.clientRequestIdHeaderName));
+	pipeline.addPolicy(multipartPolicy(), { afterPhase: "Deserialize" });
+	pipeline.addPolicy(defaultRetryPolicy(options.retryOptions), { phase: "Retry" });
+	pipeline.addPolicy(tracingPolicy({
+		...options.userAgentOptions,
+		...options.loggingOptions
+	}), { afterPhase: "Retry" });
+	if (isNodeLike) pipeline.addPolicy(redirectPolicy(options.redirectOptions), { afterPhase: "Retry" });
+	pipeline.addPolicy(logPolicy(options.loggingOptions), { afterPhase: "Sign" });
+	return pipeline;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+core-rest-pipeline@1.22.2/node_modules/@azure/core-rest-pipeline/dist/esm/util/tokenCycler.js
+const DEFAULT_CYCLER_OPTIONS = {
+	forcedRefreshWindowInMs: 1e3,
+	retryIntervalInMs: 3e3,
+	refreshWindowInMs: 1e3 * 60 * 2
+};
+/**
+* Converts an an unreliable access token getter (which may resolve with null)
+* into an AccessTokenGetter by retrying the unreliable getter in a regular
+* interval.
+*
+* @param getAccessToken - A function that produces a promise of an access token that may fail by returning null.
+* @param retryIntervalInMs - The time (in milliseconds) to wait between retry attempts.
+* @param refreshTimeout - The timestamp after which the refresh attempt will fail, throwing an exception.
+* @returns - A promise that, if it resolves, will resolve with an access token.
+*/
+async function beginRefresh(getAccessToken, retryIntervalInMs, refreshTimeout) {
+	async function tryGetAccessToken() {
+		if (Date.now() < refreshTimeout) try {
+			return await getAccessToken();
+		} catch {
+			return null;
+		}
+		else {
+			const finalToken = await getAccessToken();
+			if (finalToken === null) throw new Error("Failed to refresh access token.");
+			return finalToken;
+		}
+	}
+	let token = await tryGetAccessToken();
+	while (token === null) {
+		await delay$1(retryIntervalInMs);
+		token = await tryGetAccessToken();
+	}
+	return token;
+}
+/**
+* Creates a token cycler from a credential, scopes, and optional settings.
+*
+* A token cycler represents a way to reliably retrieve a valid access token
+* from a TokenCredential. It will handle initializing the token, refreshing it
+* when it nears expiration, and synchronizes refresh attempts to avoid
+* concurrency hazards.
+*
+* @param credential - the underlying TokenCredential that provides the access
+* token
+* @param tokenCyclerOptions - optionally override default settings for the cycler
+*
+* @returns - a function that reliably produces a valid access token
+*/
+function createTokenCycler(credential, tokenCyclerOptions) {
+	let refreshWorker = null;
+	let token = null;
+	let tenantId;
+	const options = {
+		...DEFAULT_CYCLER_OPTIONS,
+		...tokenCyclerOptions
+	};
+	/**
+	* This little holder defines several predicates that we use to construct
+	* the rules of refreshing the token.
+	*/
+	const cycler = {
+		/**
+		* Produces true if a refresh job is currently in progress.
+		*/
+		get isRefreshing() {
+			return refreshWorker !== null;
+		},
+		/**
+		* Produces true if the cycler SHOULD refresh (we are within the refresh
+		* window and not already refreshing)
+		*/
+		get shouldRefresh() {
+			if (cycler.isRefreshing) return false;
+			if (token?.refreshAfterTimestamp && token.refreshAfterTimestamp < Date.now()) return true;
+			return (token?.expiresOnTimestamp ?? 0) - options.refreshWindowInMs < Date.now();
+		},
+		/**
+		* Produces true if the cycler MUST refresh (null or nearly-expired
+		* token).
+		*/
+		get mustRefresh() {
+			return token === null || token.expiresOnTimestamp - options.forcedRefreshWindowInMs < Date.now();
+		}
+	};
+	/**
+	* Starts a refresh job or returns the existing job if one is already
+	* running.
+	*/
+	function refresh(scopes, getTokenOptions) {
+		if (!cycler.isRefreshing) {
+			const tryGetAccessToken = () => credential.getToken(scopes, getTokenOptions);
+			refreshWorker = beginRefresh(tryGetAccessToken, options.retryIntervalInMs, token?.expiresOnTimestamp ?? Date.now()).then((_token) => {
+				refreshWorker = null;
+				token = _token;
+				tenantId = getTokenOptions.tenantId;
+				return token;
+			}).catch((reason) => {
+				refreshWorker = null;
+				token = null;
+				tenantId = void 0;
+				throw reason;
+			});
+		}
+		return refreshWorker;
+	}
+	return async (scopes, tokenOptions) => {
+		const hasClaimChallenge = Boolean(tokenOptions.claims);
+		const tenantIdChanged = tenantId !== tokenOptions.tenantId;
+		if (hasClaimChallenge) token = null;
+		if (tenantIdChanged || hasClaimChallenge || cycler.mustRefresh) return refresh(scopes, tokenOptions);
+		if (cycler.shouldRefresh) refresh(scopes, tokenOptions);
+		return token;
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+core-rest-pipeline@1.22.2/node_modules/@azure/core-rest-pipeline/dist/esm/policies/bearerTokenAuthenticationPolicy.js
+/**
+* The programmatic identifier of the bearerTokenAuthenticationPolicy.
+*/
+const bearerTokenAuthenticationPolicyName = "bearerTokenAuthenticationPolicy";
+/**
+* Try to send the given request.
+*
+* When a response is received, returns a tuple of the response received and, if the response was received
+* inside a thrown RestError, the RestError that was thrown.
+*
+* Otherwise, if an error was thrown while sending the request that did not provide an underlying response, it
+* will be rethrown.
+*/
+async function trySendRequest(request, next) {
+	try {
+		return [await next(request), void 0];
+	} catch (e) {
+		if (isRestError(e) && e.response) return [e.response, e];
+		else throw e;
+	}
+}
+/**
+* Default authorize request handler
+*/
+async function defaultAuthorizeRequest(options) {
+	const { scopes, getAccessToken, request } = options;
+	const accessToken = await getAccessToken(scopes, {
+		abortSignal: request.abortSignal,
+		tracingOptions: request.tracingOptions,
+		enableCae: true
+	});
+	if (accessToken) options.request.headers.set("Authorization", `Bearer ${accessToken.token}`);
+}
+/**
+* We will retrieve the challenge only if the response status code was 401,
+* and if the response contained the header "WWW-Authenticate" with a non-empty value.
+*/
+function isChallengeResponse(response) {
+	return response.status === 401 && response.headers.has("WWW-Authenticate");
+}
+/**
+* Re-authorize the request for CAE challenge.
+* The response containing the challenge is `options.response`.
+* If this method returns true, the underlying request will be sent once again.
+*/
+async function authorizeRequestOnCaeChallenge(onChallengeOptions, caeClaims) {
+	const { scopes } = onChallengeOptions;
+	const accessToken = await onChallengeOptions.getAccessToken(scopes, {
+		enableCae: true,
+		claims: caeClaims
+	});
+	if (!accessToken) return false;
+	onChallengeOptions.request.headers.set("Authorization", `${accessToken.tokenType ?? "Bearer"} ${accessToken.token}`);
+	return true;
+}
+/**
+* A policy that can request a token from a TokenCredential implementation and
+* then apply it to the Authorization header of a request as a Bearer token.
+*/
+function bearerTokenAuthenticationPolicy(options) {
+	const { credential, scopes, challengeCallbacks } = options;
+	const logger$2 = options.logger || logger;
+	const callbacks = {
+		authorizeRequest: challengeCallbacks?.authorizeRequest?.bind(challengeCallbacks) ?? defaultAuthorizeRequest,
+		authorizeRequestOnChallenge: challengeCallbacks?.authorizeRequestOnChallenge?.bind(challengeCallbacks)
+	};
+	const getAccessToken = credential ? createTokenCycler(credential) : () => Promise.resolve(null);
+	return {
+		name: bearerTokenAuthenticationPolicyName,
+		/**
+		* If there's no challenge parameter:
+		* - It will try to retrieve the token using the cache, or the credential's getToken.
+		* - Then it will try the next policy with or without the retrieved token.
+		*
+		* It uses the challenge parameters to:
+		* - Skip a first attempt to get the token from the credential if there's no cached token,
+		*   since it expects the token to be retrievable only after the challenge.
+		* - Prepare the outgoing request if the `prepareRequest` method has been provided.
+		* - Send an initial request to receive the challenge if it fails.
+		* - Process a challenge if the response contains it.
+		* - Retrieve a token with the challenge information, then re-send the request.
+		*/
+		async sendRequest(request, next) {
+			if (!request.url.toLowerCase().startsWith("https://")) throw new Error("Bearer token authentication is not permitted for non-TLS protected (non-https) URLs.");
+			await callbacks.authorizeRequest({
+				scopes: Array.isArray(scopes) ? scopes : [scopes],
+				request,
+				getAccessToken,
+				logger: logger$2
+			});
+			let response;
+			let error;
+			let shouldSendRequest;
+			[response, error] = await trySendRequest(request, next);
+			if (isChallengeResponse(response)) {
+				let claims = getCaeChallengeClaims(response.headers.get("WWW-Authenticate"));
+				if (claims) {
+					let parsedClaim;
+					try {
+						parsedClaim = atob(claims);
+					} catch (e) {
+						logger$2.warning(`The WWW-Authenticate header contains "claims" that cannot be parsed. Unable to perform the Continuous Access Evaluation authentication flow. Unparsable claims: ${claims}`);
+						return response;
+					}
+					shouldSendRequest = await authorizeRequestOnCaeChallenge({
+						scopes: Array.isArray(scopes) ? scopes : [scopes],
+						response,
+						request,
+						getAccessToken,
+						logger: logger$2
+					}, parsedClaim);
+					if (shouldSendRequest) [response, error] = await trySendRequest(request, next);
+				} else if (callbacks.authorizeRequestOnChallenge) {
+					shouldSendRequest = await callbacks.authorizeRequestOnChallenge({
+						scopes: Array.isArray(scopes) ? scopes : [scopes],
+						request,
+						response,
+						getAccessToken,
+						logger: logger$2
+					});
+					if (shouldSendRequest) [response, error] = await trySendRequest(request, next);
+					if (isChallengeResponse(response)) {
+						claims = getCaeChallengeClaims(response.headers.get("WWW-Authenticate"));
+						if (claims) {
+							let parsedClaim;
+							try {
+								parsedClaim = atob(claims);
+							} catch (e) {
+								logger$2.warning(`The WWW-Authenticate header contains "claims" that cannot be parsed. Unable to perform the Continuous Access Evaluation authentication flow. Unparsable claims: ${claims}`);
+								return response;
+							}
+							shouldSendRequest = await authorizeRequestOnCaeChallenge({
+								scopes: Array.isArray(scopes) ? scopes : [scopes],
+								response,
+								request,
+								getAccessToken,
+								logger: logger$2
+							}, parsedClaim);
+							if (shouldSendRequest) [response, error] = await trySendRequest(request, next);
+						}
+					}
+				}
+			}
+			if (error) throw error;
+			else return response;
+		}
+	};
+}
+/**
+* Converts: `Bearer a="b", c="d", Pop e="f", g="h"`.
+* Into: `[ { scheme: 'Bearer', params: { a: 'b', c: 'd' } }, { scheme: 'Pop', params: { e: 'f', g: 'h' } } ]`.
+*
+* @internal
+*/
+function parseChallenges(challenges) {
+	const challengeRegex = /(\w+)\s+((?:\w+=(?:"[^"]*"|[^,]*),?\s*)+)/g;
+	const paramRegex = /(\w+)="([^"]*)"/g;
+	const parsedChallenges = [];
+	let match;
+	while ((match = challengeRegex.exec(challenges)) !== null) {
+		const scheme = match[1];
+		const paramsString = match[2];
+		const params = {};
+		let paramMatch;
+		while ((paramMatch = paramRegex.exec(paramsString)) !== null) params[paramMatch[1]] = paramMatch[2];
+		parsedChallenges.push({
+			scheme,
+			params
+		});
+	}
+	return parsedChallenges;
+}
+/**
+* Parse a pipeline response and look for a CAE challenge with "Bearer" scheme
+* Return the value in the header without parsing the challenge
+* @internal
+*/
+function getCaeChallengeClaims(challenges) {
+	if (!challenges) return;
+	return parseChallenges(challenges).find((x) => x.scheme === "Bearer" && x.params.claims && x.params.error === "insufficient_claims")?.params.claims;
+}
+//#endregion
+export { isNode as A, createTracingClient as B, RestError$1 as C, createHttpHeaders as D, createPipelineRequest as E, delay$1 as F, getLogLevel as H, AbortError$1 as I, stringToUint8Array$1 as L, stringToUint8Array as M, uint8ArrayToString as N, calculateRetryDelay as O, isObjectWithProperties as P, uint8ArrayToString$1 as R, logger$1 as S, createEmptyPipeline$1 as T, createClientLogger as V, decompressResponsePolicy$1 as _, RestError as a, logPolicy$1 as b, multipartPolicyName$1 as c, tlsPolicy$1 as d, agentPolicy$1 as f, retryPolicy as g, defaultRetryPolicy$1 as h, wrapAbortSignalLike as i, isNodeLike as j, isError as k, isBinaryBody as l, formDataPolicy$1 as m, bearerTokenAuthenticationPolicyName as n, createEmptyPipeline as o, proxyPolicy$1 as p, createPipelineFromOptions as r, multipartPolicy$1 as s, bearerTokenAuthenticationPolicy as t, isReadableStream as u, SDK_VERSION$1 as v, isRestError$1 as w, createDefaultHttpClient as x, redirectPolicy$1 as y, isNodeLike$1 as z };