@alienplatform/sdk 1.10.7 → 1.11.1

package/dist/esm2.js

@@ -0,0 +1,3104 @@
+import { a as __rest, i as __await, n as __asyncGenerator, o as init_tslib_es6, r as __asyncValues, t as __asyncDelegator } from "./tslib.es6.js";
+import { B as createTracingClient, C as RestError, D as createHttpHeaders, E as createPipelineRequest, F as delay, L as stringToUint8Array, M as stringToUint8Array$1, N as uint8ArrayToString$1, P as isObjectWithProperties, R as uint8ArrayToString, S as logger$3, T as createEmptyPipeline, V as createClientLogger, _ as decompressResponsePolicy, a as RestError$1, b as logPolicy, c as multipartPolicyName, d as tlsPolicy, f as agentPolicy, h as defaultRetryPolicy, l as isBinaryBody, m as formDataPolicy, n as bearerTokenAuthenticationPolicyName, p as proxyPolicy, r as createPipelineFromOptions$1, s as multipartPolicy, t as bearerTokenAuthenticationPolicy, u as isReadableStream, v as SDK_VERSION$1, w as isRestError, x as createDefaultHttpClient, y as redirectPolicy, z as isNodeLike } from "./bearerTokenAuthenticationPolicy.js";
+import os from "node:os";
+import process$1 from "node:process";
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/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/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/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("ts-http-runtime", SDK_VERSION$1);
+	await setPlatformSpecificData(runtimeInfo);
+	const defaultAgent = getUserAgentString(runtimeInfo);
+	return prefix ? `${prefix} ${defaultAgent}` : defaultAgent;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/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/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/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(formDataPolicy(), { beforePolicies: [multipartPolicyName] });
+	pipeline.addPolicy(userAgentPolicy(options.userAgentOptions));
+	pipeline.addPolicy(multipartPolicy(), { afterPhase: "Deserialize" });
+	pipeline.addPolicy(defaultRetryPolicy(options.retryOptions), { phase: "Retry" });
+	if (isNodeLike) pipeline.addPolicy(redirectPolicy(options.redirectOptions), { afterPhase: "Retry" });
+	pipeline.addPolicy(logPolicy(options.loggingOptions), { afterPhase: "Sign" });
+	return pipeline;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/client/apiVersionPolicy.js
+const apiVersionPolicyName$1 = "ApiVersionPolicy";
+/**
+* Creates a policy that sets the apiVersion as a query parameter on every request
+* @param options - Client options
+* @returns Pipeline policy that sets the apiVersion as a query parameter on every request
+*/
+function apiVersionPolicy$1(options) {
+	return {
+		name: apiVersionPolicyName$1,
+		sendRequest: (req, next) => {
+			const url = new URL(req.url);
+			if (!url.searchParams.get("api-version") && options.apiVersion) req.url = `${req.url}${Array.from(url.searchParams.keys()).length > 0 ? "&" : "?"}api-version=${options.apiVersion}`;
+			return next(req);
+		}
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/auth/credentials.js
+/**
+* Type guard to check if a credential is an OAuth2 token credential.
+*/
+function isOAuth2TokenCredential(credential) {
+	return "getOAuth2Token" in credential;
+}
+/**
+* Type guard to check if a credential is a Bearer token credential.
+*/
+function isBearerTokenCredential(credential) {
+	return "getBearerToken" in credential;
+}
+/**
+* Type guard to check if a credential is a Basic auth credential.
+*/
+function isBasicCredential(credential) {
+	return "username" in credential && "password" in credential;
+}
+/**
+* Type guard to check if a credential is an API key credential.
+*/
+function isApiKeyCredential(credential) {
+	return "key" in credential;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/policies/auth/checkInsecureConnection.js
+let insecureConnectionWarningEmmitted = false;
+/**
+* Checks if the request is allowed to be sent over an insecure connection.
+*
+* A request is allowed to be sent over an insecure connection when:
+* - The `allowInsecureConnection` option is set to `true`.
+* - The request has the `allowInsecureConnection` property set to `true`.
+* - The request is being sent to `localhost` or `127.0.0.1`
+*/
+function allowInsecureConnection(request, options) {
+	if (options.allowInsecureConnection && request.allowInsecureConnection) {
+		const url = new URL(request.url);
+		if (url.hostname === "localhost" || url.hostname === "127.0.0.1") return true;
+	}
+	return false;
+}
+/**
+* Logs a warning about sending a token over an insecure connection.
+*
+* This function will emit a node warning once, but log the warning every time.
+*/
+function emitInsecureConnectionWarning() {
+	const warning = "Sending token over insecure transport. Assume any token issued is compromised.";
+	logger$3.warning(warning);
+	if (typeof process?.emitWarning === "function" && !insecureConnectionWarningEmmitted) {
+		insecureConnectionWarningEmmitted = true;
+		process.emitWarning(warning);
+	}
+}
+/**
+* Ensures that authentication is only allowed over HTTPS unless explicitly allowed.
+* Throws an error if the connection is not secure and not explicitly allowed.
+*/
+function ensureSecureConnection(request, options) {
+	if (!request.url.toLowerCase().startsWith("https://")) if (allowInsecureConnection(request, options)) emitInsecureConnectionWarning();
+	else throw new Error("Authentication is not permitted for non-TLS protected (non-https) URLs when allowInsecureConnection is false.");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/policies/auth/apiKeyAuthenticationPolicy.js
+/**
+* Name of the API Key Authentication Policy
+*/
+const apiKeyAuthenticationPolicyName = "apiKeyAuthenticationPolicy";
+/**
+* Gets a pipeline policy that adds API key authentication to requests
+*/
+function apiKeyAuthenticationPolicy(options) {
+	return {
+		name: apiKeyAuthenticationPolicyName,
+		async sendRequest(request, next) {
+			ensureSecureConnection(request, options);
+			const scheme = (request.authSchemes ?? options.authSchemes)?.find((x) => x.kind === "apiKey");
+			if (!scheme) return next(request);
+			if (scheme.apiKeyLocation !== "header") throw new Error(`Unsupported API key location: ${scheme.apiKeyLocation}`);
+			request.headers.set(scheme.name, options.credential.key);
+			return next(request);
+		}
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/policies/auth/basicAuthenticationPolicy.js
+/**
+* Name of the Basic Authentication Policy
+*/
+const basicAuthenticationPolicyName = "bearerAuthenticationPolicy";
+/**
+* Gets a pipeline policy that adds basic authentication to requests
+*/
+function basicAuthenticationPolicy(options) {
+	return {
+		name: basicAuthenticationPolicyName,
+		async sendRequest(request, next) {
+			ensureSecureConnection(request, options);
+			if (!(request.authSchemes ?? options.authSchemes)?.find((x) => x.kind === "http" && x.scheme === "basic")) return next(request);
+			const { username, password } = options.credential;
+			const headerValue = uint8ArrayToString(stringToUint8Array(`${username}:${password}`, "utf-8"), "base64");
+			request.headers.set("Authorization", `Basic ${headerValue}`);
+			return next(request);
+		}
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/policies/auth/bearerAuthenticationPolicy.js
+/**
+* Name of the Bearer Authentication Policy
+*/
+const bearerAuthenticationPolicyName = "bearerAuthenticationPolicy";
+/**
+* Gets a pipeline policy that adds bearer token authentication to requests
+*/
+function bearerAuthenticationPolicy(options) {
+	return {
+		name: bearerAuthenticationPolicyName,
+		async sendRequest(request, next) {
+			ensureSecureConnection(request, options);
+			if (!(request.authSchemes ?? options.authSchemes)?.find((x) => x.kind === "http" && x.scheme === "bearer")) return next(request);
+			const token = await options.credential.getBearerToken({ abortSignal: request.abortSignal });
+			request.headers.set("Authorization", `Bearer ${token}`);
+			return next(request);
+		}
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/policies/auth/oauth2AuthenticationPolicy.js
+/**
+* Name of the OAuth2 Authentication Policy
+*/
+const oauth2AuthenticationPolicyName = "oauth2AuthenticationPolicy";
+/**
+* Gets a pipeline policy that adds authorization header from OAuth2 schemes
+*/
+function oauth2AuthenticationPolicy(options) {
+	return {
+		name: oauth2AuthenticationPolicyName,
+		async sendRequest(request, next) {
+			ensureSecureConnection(request, options);
+			const scheme = (request.authSchemes ?? options.authSchemes)?.find((x) => x.kind === "oauth2");
+			if (!scheme) return next(request);
+			const token = await options.credential.getOAuth2Token(scheme.flows, { abortSignal: request.abortSignal });
+			request.headers.set("Authorization", `Bearer ${token}`);
+			return next(request);
+		}
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/client/clientHelpers.js
+let cachedHttpClient;
+/**
+* Creates a default rest pipeline to re-use accross Rest Level Clients
+*/
+function createDefaultPipeline$1(options = {}) {
+	const pipeline = createPipelineFromOptions(options);
+	pipeline.addPolicy(apiVersionPolicy$1(options));
+	const { credential, authSchemes, allowInsecureConnection } = options;
+	if (credential) {
+		if (isApiKeyCredential(credential)) pipeline.addPolicy(apiKeyAuthenticationPolicy({
+			authSchemes,
+			credential,
+			allowInsecureConnection
+		}));
+		else if (isBasicCredential(credential)) pipeline.addPolicy(basicAuthenticationPolicy({
+			authSchemes,
+			credential,
+			allowInsecureConnection
+		}));
+		else if (isBearerTokenCredential(credential)) pipeline.addPolicy(bearerAuthenticationPolicy({
+			authSchemes,
+			credential,
+			allowInsecureConnection
+		}));
+		else if (isOAuth2TokenCredential(credential)) pipeline.addPolicy(oauth2AuthenticationPolicy({
+			authSchemes,
+			credential,
+			allowInsecureConnection
+		}));
+	}
+	return pipeline;
+}
+function getCachedDefaultHttpsClient() {
+	if (!cachedHttpClient) cachedHttpClient = createDefaultHttpClient();
+	return cachedHttpClient;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/client/multipart.js
+/**
+* Get value of a header in the part descriptor ignoring case
+*/
+function getHeaderValue(descriptor, headerName) {
+	if (descriptor.headers) {
+		const actualHeaderName = Object.keys(descriptor.headers).find((x) => x.toLowerCase() === headerName.toLowerCase());
+		if (actualHeaderName) return descriptor.headers[actualHeaderName];
+	}
+}
+function getPartContentType(descriptor) {
+	const contentTypeHeader = getHeaderValue(descriptor, "content-type");
+	if (contentTypeHeader) return contentTypeHeader;
+	if (descriptor.contentType === null) return;
+	if (descriptor.contentType) return descriptor.contentType;
+	const { body } = descriptor;
+	if (body === null || body === void 0) return;
+	if (typeof body === "string" || typeof body === "number" || typeof body === "boolean") return "text/plain; charset=UTF-8";
+	if (body instanceof Blob) return body.type || "application/octet-stream";
+	if (isBinaryBody(body)) return "application/octet-stream";
+	return "application/json";
+}
+/**
+* Enclose value in quotes and escape special characters, for use in the Content-Disposition header
+*/
+function escapeDispositionField(value) {
+	return JSON.stringify(value);
+}
+function getContentDisposition(descriptor) {
+	const contentDispositionHeader = getHeaderValue(descriptor, "content-disposition");
+	if (contentDispositionHeader) return contentDispositionHeader;
+	if (descriptor.dispositionType === void 0 && descriptor.name === void 0 && descriptor.filename === void 0) return;
+	let disposition = descriptor.dispositionType ?? "form-data";
+	if (descriptor.name) disposition += `; name=${escapeDispositionField(descriptor.name)}`;
+	let filename = void 0;
+	if (descriptor.filename) filename = descriptor.filename;
+	else if (typeof File !== "undefined" && descriptor.body instanceof File) {
+		const filenameFromFile = descriptor.body.name;
+		if (filenameFromFile !== "") filename = filenameFromFile;
+	}
+	if (filename) disposition += `; filename=${escapeDispositionField(filename)}`;
+	return disposition;
+}
+function normalizeBody(body, contentType) {
+	if (body === void 0) return new Uint8Array([]);
+	if (isBinaryBody(body)) return body;
+	if (typeof body === "string" || typeof body === "number" || typeof body === "boolean") return stringToUint8Array(String(body), "utf-8");
+	if (contentType && /application\/(.+\+)?json(;.+)?/i.test(String(contentType))) return stringToUint8Array(JSON.stringify(body), "utf-8");
+	throw new RestError(`Unsupported body/content-type combination: ${body}, ${contentType}`);
+}
+function buildBodyPart(descriptor) {
+	const contentType = getPartContentType(descriptor);
+	const contentDisposition = getContentDisposition(descriptor);
+	const headers = createHttpHeaders(descriptor.headers ?? {});
+	if (contentType) headers.set("content-type", contentType);
+	if (contentDisposition) headers.set("content-disposition", contentDisposition);
+	return {
+		headers,
+		body: normalizeBody(descriptor.body, contentType)
+	};
+}
+function buildMultipartBody(parts) {
+	return { parts: parts.map(buildBodyPart) };
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/client/sendRequest.js
+/**
+* Helper function to send request used by the client
+* @param method - method to use to send the request
+* @param url - url to send the request to
+* @param pipeline - pipeline with the policies to run when sending the request
+* @param options - request options
+* @param customHttpClient - a custom HttpClient to use when making the request
+* @returns returns and HttpResponse
+*/
+async function sendRequest(method, url, pipeline, options = {}, customHttpClient) {
+	const httpClient = customHttpClient ?? getCachedDefaultHttpsClient();
+	const request = buildPipelineRequest(method, url, options);
+	try {
+		const response = await pipeline.sendRequest(httpClient, request);
+		const headers = response.headers.toJSON();
+		const stream = response.readableStreamBody ?? response.browserStreamBody;
+		const parsedBody = options.responseAsStream || stream !== void 0 ? void 0 : getResponseBody(response);
+		const body = stream ?? parsedBody;
+		if (options?.onResponse) options.onResponse({
+			...response,
+			request,
+			rawHeaders: headers,
+			parsedBody
+		});
+		return {
+			request,
+			headers,
+			status: `${response.status}`,
+			body
+		};
+	} catch (e) {
+		if (isRestError(e) && e.response && options.onResponse) {
+			const { response } = e;
+			const rawHeaders = response.headers.toJSON();
+			options?.onResponse({
+				...response,
+				request,
+				rawHeaders
+			}, e);
+		}
+		throw e;
+	}
+}
+/**
+* Function to determine the request content type
+* @param options - request options InternalRequestParameters
+* @returns returns the content-type
+*/
+function getRequestContentType(options = {}) {
+	return options.contentType ?? options.headers?.["content-type"] ?? getContentType(options.body);
+}
+/**
+* Function to determine the content-type of a body
+* this is used if an explicit content-type is not provided
+* @param body - body in the request
+* @returns returns the content-type
+*/
+function getContentType(body) {
+	if (ArrayBuffer.isView(body)) return "application/octet-stream";
+	if (typeof body === "string") try {
+		JSON.parse(body);
+		return "application/json";
+	} catch (error) {
+		return;
+	}
+	return "application/json";
+}
+function buildPipelineRequest(method, url, options = {}) {
+	const requestContentType = getRequestContentType(options);
+	const { body, multipartBody } = getRequestBody(options.body, requestContentType);
+	const hasContent = body !== void 0 || multipartBody !== void 0;
+	return createPipelineRequest({
+		url,
+		method,
+		body,
+		multipartBody,
+		headers: createHttpHeaders({
+			...options.headers ? options.headers : {},
+			accept: options.accept ?? options.headers?.accept ?? "application/json",
+			...hasContent && requestContentType && { "content-type": requestContentType }
+		}),
+		allowInsecureConnection: options.allowInsecureConnection,
+		abortSignal: options.abortSignal,
+		onUploadProgress: options.onUploadProgress,
+		onDownloadProgress: options.onDownloadProgress,
+		timeout: options.timeout,
+		enableBrowserStreams: true,
+		streamResponseStatusCodes: options.responseAsStream ? new Set([Number.POSITIVE_INFINITY]) : void 0
+	});
+}
+/**
+* Prepares the body before sending the request
+*/
+function getRequestBody(body, contentType = "") {
+	if (body === void 0) return { body: void 0 };
+	if (typeof FormData !== "undefined" && body instanceof FormData) return { body };
+	if (isReadableStream(body)) return { body };
+	if (ArrayBuffer.isView(body)) return { body: body instanceof Uint8Array ? body : JSON.stringify(body) };
+	switch (contentType.split(";")[0]) {
+		case "application/json": return { body: JSON.stringify(body) };
+		case "multipart/form-data":
+			if (Array.isArray(body)) return { multipartBody: buildMultipartBody(body) };
+			return { body: JSON.stringify(body) };
+		case "text/plain": return { body: String(body) };
+		default:
+			if (typeof body === "string") return { body };
+			return { body: JSON.stringify(body) };
+	}
+}
+/**
+* Prepares the response body
+*/
+function getResponseBody(response) {
+	const firstType = (response.headers.get("content-type") ?? "").split(";")[0];
+	const bodyToParse = response.bodyAsText ?? "";
+	if (firstType === "text/plain") return String(bodyToParse);
+	try {
+		return bodyToParse ? JSON.parse(bodyToParse) : void 0;
+	} catch (error) {
+		if (firstType === "application/json") throw createParseError(response, error);
+		return String(bodyToParse);
+	}
+}
+function createParseError(response, err) {
+	return new RestError(`Error "${err}" occurred while parsing the response body - ${response.bodyAsText}.`, {
+		code: err.code ?? RestError.PARSE_ERROR,
+		statusCode: response.status,
+		request: response.request,
+		response
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/client/urlHelpers.js
+function isQueryParameterWithOptions(x) {
+	const value = x.value;
+	return value !== void 0 && value.toString !== void 0 && typeof value.toString === "function";
+}
+/**
+* Builds the request url, filling in query and path parameters
+* @param endpoint - base url which can be a template url
+* @param routePath - path to append to the endpoint
+* @param pathParameters - values of the path parameters
+* @param options - request parameters including query parameters
+* @returns a full url with path and query parameters
+*/
+function buildRequestUrl(endpoint, routePath, pathParameters, options = {}) {
+	if (routePath.startsWith("https://") || routePath.startsWith("http://")) return routePath;
+	endpoint = buildBaseUrl(endpoint, options);
+	routePath = buildRoutePath(routePath, pathParameters, options);
+	const requestUrl = appendQueryParams(`${endpoint}/${routePath}`, options);
+	return new URL(requestUrl).toString().replace(/([^:]\/)\/+/g, "$1");
+}
+function getQueryParamValue(key, allowReserved, style, param) {
+	let separator;
+	if (style === "pipeDelimited") separator = "|";
+	else if (style === "spaceDelimited") separator = "%20";
+	else separator = ",";
+	let paramValues;
+	if (Array.isArray(param)) paramValues = param;
+	else if (typeof param === "object" && param.toString === Object.prototype.toString) paramValues = Object.entries(param).flat();
+	else paramValues = [param];
+	const value = paramValues.map((p) => {
+		if (p === null || p === void 0) return "";
+		if (!p.toString || typeof p.toString !== "function") throw new Error(`Query parameters must be able to be represented as string, ${key} can't`);
+		const rawValue = p.toISOString !== void 0 ? p.toISOString() : p.toString();
+		return allowReserved ? rawValue : encodeURIComponent(rawValue);
+	}).join(separator);
+	return `${allowReserved ? key : encodeURIComponent(key)}=${value}`;
+}
+function appendQueryParams(url, options = {}) {
+	if (!options.queryParameters) return url;
+	const parsedUrl = new URL(url);
+	const queryParams = options.queryParameters;
+	const paramStrings = [];
+	for (const key of Object.keys(queryParams)) {
+		const param = queryParams[key];
+		if (param === void 0 || param === null) continue;
+		const hasMetadata = isQueryParameterWithOptions(param);
+		const rawValue = hasMetadata ? param.value : param;
+		const explode = hasMetadata ? param.explode ?? false : false;
+		const style = hasMetadata && param.style ? param.style : "form";
+		if (explode) if (Array.isArray(rawValue)) for (const item of rawValue) paramStrings.push(getQueryParamValue(key, options.skipUrlEncoding ?? false, style, item));
+		else if (typeof rawValue === "object") for (const [actualKey, value] of Object.entries(rawValue)) paramStrings.push(getQueryParamValue(actualKey, options.skipUrlEncoding ?? false, style, value));
+		else throw new Error("explode can only be set to true for objects and arrays");
+		else paramStrings.push(getQueryParamValue(key, options.skipUrlEncoding ?? false, style, rawValue));
+	}
+	if (parsedUrl.search !== "") parsedUrl.search += "&";
+	parsedUrl.search += paramStrings.join("&");
+	return parsedUrl.toString();
+}
+function buildBaseUrl(endpoint, options) {
+	if (!options.pathParameters) return endpoint;
+	const pathParams = options.pathParameters;
+	for (const [key, param] of Object.entries(pathParams)) {
+		if (param === void 0 || param === null) throw new Error(`Path parameters ${key} must not be undefined or null`);
+		if (!param.toString || typeof param.toString !== "function") throw new Error(`Path parameters must be able to be represented as string, ${key} can't`);
+		let value = param.toISOString !== void 0 ? param.toISOString() : String(param);
+		if (!options.skipUrlEncoding) value = encodeURIComponent(param);
+		endpoint = replaceAll(endpoint, `{${key}}`, value) ?? "";
+	}
+	return endpoint;
+}
+function buildRoutePath(routePath, pathParameters, options = {}) {
+	for (const pathParam of pathParameters) {
+		const allowReserved = typeof pathParam === "object" && (pathParam.allowReserved ?? false);
+		let value = typeof pathParam === "object" ? pathParam.value : pathParam;
+		if (!options.skipUrlEncoding && !allowReserved) value = encodeURIComponent(value);
+		routePath = routePath.replace(/\{[\w-]+\}/, String(value));
+	}
+	return routePath;
+}
+/**
+* Replace all of the instances of searchValue in value with the provided replaceValue.
+* @param value - The value to search and replace in.
+* @param searchValue - The value to search for in the value argument.
+* @param replaceValue - The value to replace searchValue with in the value argument.
+* @returns The value where each instance of searchValue was replaced with replacedValue.
+*/
+function replaceAll(value, searchValue, replaceValue) {
+	return !value || !searchValue ? value : value.split(searchValue).join(replaceValue || "");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/client/getClient.js
+/**
+* Creates a client with a default pipeline
+* @param endpoint - Base endpoint for the client
+* @param credentials - Credentials to authenticate the requests
+* @param options - Client options
+*/
+function getClient$1(endpoint, clientOptions = {}) {
+	const pipeline = clientOptions.pipeline ?? createDefaultPipeline$1(clientOptions);
+	if (clientOptions.additionalPolicies?.length) for (const { policy, position } of clientOptions.additionalPolicies) {
+		const afterPhase = position === "perRetry" ? "Sign" : void 0;
+		pipeline.addPolicy(policy, { afterPhase });
+	}
+	const { allowInsecureConnection, httpClient } = clientOptions;
+	const endpointUrl = clientOptions.endpoint ?? endpoint;
+	const client = (path, ...args) => {
+		const getUrl = (requestOptions) => buildRequestUrl(endpointUrl, path, args, {
+			allowInsecureConnection,
+			...requestOptions
+		});
+		return {
+			get: (requestOptions = {}) => {
+				return buildOperation("GET", getUrl(requestOptions), pipeline, requestOptions, allowInsecureConnection, httpClient);
+			},
+			post: (requestOptions = {}) => {
+				return buildOperation("POST", getUrl(requestOptions), pipeline, requestOptions, allowInsecureConnection, httpClient);
+			},
+			put: (requestOptions = {}) => {
+				return buildOperation("PUT", getUrl(requestOptions), pipeline, requestOptions, allowInsecureConnection, httpClient);
+			},
+			patch: (requestOptions = {}) => {
+				return buildOperation("PATCH", getUrl(requestOptions), pipeline, requestOptions, allowInsecureConnection, httpClient);
+			},
+			delete: (requestOptions = {}) => {
+				return buildOperation("DELETE", getUrl(requestOptions), pipeline, requestOptions, allowInsecureConnection, httpClient);
+			},
+			head: (requestOptions = {}) => {
+				return buildOperation("HEAD", getUrl(requestOptions), pipeline, requestOptions, allowInsecureConnection, httpClient);
+			},
+			options: (requestOptions = {}) => {
+				return buildOperation("OPTIONS", getUrl(requestOptions), pipeline, requestOptions, allowInsecureConnection, httpClient);
+			},
+			trace: (requestOptions = {}) => {
+				return buildOperation("TRACE", getUrl(requestOptions), pipeline, requestOptions, allowInsecureConnection, httpClient);
+			}
+		};
+	};
+	return {
+		path: client,
+		pathUnchecked: client,
+		pipeline
+	};
+}
+function buildOperation(method, url, pipeline, options, allowInsecureConnection, httpClient) {
+	allowInsecureConnection = options.allowInsecureConnection ?? allowInsecureConnection;
+	return {
+		then: function(onFulfilled, onrejected) {
+			return sendRequest(method, url, pipeline, {
+				...options,
+				allowInsecureConnection
+			}, httpClient).then(onFulfilled, onrejected);
+		},
+		async asBrowserStream() {
+			if (isNodeLike) throw new Error("`asBrowserStream` is supported only in the browser environment. Use `asNodeStream` instead to obtain the response body stream. If you require a Web stream of the response in Node, consider using `Readable.toWeb` on the result of `asNodeStream`.");
+			else return sendRequest(method, url, pipeline, {
+				...options,
+				allowInsecureConnection,
+				responseAsStream: true
+			}, httpClient);
+		},
+		async asNodeStream() {
+			if (isNodeLike) return sendRequest(method, url, pipeline, {
+				...options,
+				allowInsecureConnection,
+				responseAsStream: true
+			}, httpClient);
+			else throw new Error("`isNodeStream` is not supported in the browser environment. Use `asBrowserStream` to obtain the response body stream.");
+		}
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/client/operationOptionHelpers.js
+/**
+* Helper function to convert OperationOptions to RequestParameters
+* @param options - the options that are used by Modular layer to send the request
+* @returns the result of the conversion in RequestParameters of RLC layer
+*/
+function operationOptionsToRequestParameters$1(options) {
+	return {
+		allowInsecureConnection: options.requestOptions?.allowInsecureConnection,
+		timeout: options.requestOptions?.timeout,
+		skipUrlEncoding: options.requestOptions?.skipUrlEncoding,
+		abortSignal: options.abortSignal,
+		onUploadProgress: options.requestOptions?.onUploadProgress,
+		onDownloadProgress: options.requestOptions?.onDownloadProgress,
+		headers: { ...options.requestOptions?.headers },
+		onResponse: options.onResponse
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.3.2/node_modules/@typespec/ts-http-runtime/dist/esm/client/restError.js
+function createRestError$1(messageOrResponse, response) {
+	const resp = typeof messageOrResponse === "string" ? response : messageOrResponse;
+	const internalError = resp.body?.error ?? resp.body;
+	return new RestError(typeof messageOrResponse === "string" ? messageOrResponse : internalError?.message ?? `Unexpected status code: ${resp.status}`, {
+		statusCode: statusCodeToNumber(resp.status),
+		code: internalError?.code,
+		request: resp.request,
+		response: toPipelineResponse(resp)
+	});
+}
+function toPipelineResponse(response) {
+	return {
+		headers: createHttpHeaders(response.headers),
+		request: response.request,
+		status: statusCodeToNumber(response.status) ?? -1
+	};
+}
+function statusCodeToNumber(statusCode) {
+	const status = Number.parseInt(statusCode);
+	return Number.isNaN(status) ? void 0 : status;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+keyvault-secrets@4.10.0/node_modules/@azure/keyvault-secrets/dist/esm/log.js
+init_tslib_es6();
+/**
+* The \@azure/logger configuration for this package.
+*/
+const logger = createClientLogger("keyvault-secrets");
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+keyvault-secrets@4.10.0/node_modules/@azure/keyvault-secrets/dist/esm/generated/logger.js
+const logger$2 = createClientLogger("keyvault-secrets");
+//#endregion
+//#region ../../node_modules/.pnpm/@azure-rest+core-client@2.5.1/node_modules/@azure-rest/core-client/dist/esm/restError.js
+function createRestError(messageOrResponse, response) {
+	if (typeof messageOrResponse === "string") return createRestError$1(messageOrResponse, response);
+	else return createRestError$1(messageOrResponse);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@azure-rest+core-client@2.5.1/node_modules/@azure-rest/core-client/dist/esm/operationOptionHelpers.js
+/**
+* Helper function to convert OperationOptions to RequestParameters
+* @param options - the options that are used by Modular layer to send the request
+* @returns the result of the conversion in RequestParameters of RLC layer
+*/
+function operationOptionsToRequestParameters(options) {
+	return operationOptionsToRequestParameters$1(options);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+core-auth@1.10.1/node_modules/@azure/core-auth/dist/esm/keyCredential.js
+/**
+* Tests an object to determine whether it implements KeyCredential.
+*
+* @param credential - The assumed KeyCredential to be tested.
+*/
+function isKeyCredential$1(credential) {
+	return isObjectWithProperties(credential, ["key"]) && typeof credential.key === "string";
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+core-auth@1.10.1/node_modules/@azure/core-auth/dist/esm/tokenCredential.js
+/**
+* Tests an object to determine whether it implements TokenCredential.
+*
+* @param credential - The assumed TokenCredential to be tested.
+*/
+function isTokenCredential(credential) {
+	const castCredential = credential;
+	return castCredential && typeof castCredential.getToken === "function" && (castCredential.signRequest === void 0 || castCredential.getToken.length > 0);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@azure-rest+core-client@2.5.1/node_modules/@azure-rest/core-client/dist/esm/apiVersionPolicy.js
+const apiVersionPolicyName = "ApiVersionPolicy";
+/**
+* Creates a policy that sets the apiVersion as a query parameter on every request
+* @param options - Client options
+* @returns Pipeline policy that sets the apiVersion as a query parameter on every request
+*/
+function apiVersionPolicy(options) {
+	return {
+		name: apiVersionPolicyName,
+		sendRequest: (req, next) => {
+			const url = new URL(req.url);
+			if (!url.searchParams.get("api-version") && options.apiVersion) req.url = `${req.url}${Array.from(url.searchParams.keys()).length > 0 ? "&" : "?"}api-version=${options.apiVersion}`;
+			return next(req);
+		}
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@azure-rest+core-client@2.5.1/node_modules/@azure-rest/core-client/dist/esm/keyCredentialAuthenticationPolicy.js
+/**
+* The programmatic identifier of the bearerTokenAuthenticationPolicy.
+*/
+const keyCredentialAuthenticationPolicyName = "keyCredentialAuthenticationPolicy";
+function keyCredentialAuthenticationPolicy(credential, apiKeyHeaderName) {
+	return {
+		name: keyCredentialAuthenticationPolicyName,
+		async sendRequest(request, next) {
+			request.headers.set(apiKeyHeaderName, credential.key);
+			return next(request);
+		}
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@azure-rest+core-client@2.5.1/node_modules/@azure-rest/core-client/dist/esm/clientHelpers.js
+/**
+* Adds a credential policy to the pipeline if a credential is provided. If none is provided, no policy is added.
+*/
+function addCredentialPipelinePolicy(pipeline, endpoint, options = {}) {
+	const { credential, clientOptions } = options;
+	if (!credential) return;
+	if (isTokenCredential(credential)) {
+		const tokenPolicy = bearerTokenAuthenticationPolicy({
+			credential,
+			scopes: clientOptions?.credentials?.scopes ?? `${endpoint}/.default`
+		});
+		pipeline.addPolicy(tokenPolicy);
+	} else if (isKeyCredential(credential)) {
+		if (!clientOptions?.credentials?.apiKeyHeaderName) throw new Error(`Missing API Key Header Name`);
+		const keyPolicy = keyCredentialAuthenticationPolicy(credential, clientOptions?.credentials?.apiKeyHeaderName);
+		pipeline.addPolicy(keyPolicy);
+	}
+}
+/**
+* Creates a default rest pipeline to re-use accross Rest Level Clients
+*/
+function createDefaultPipeline(endpoint, credential, options = {}) {
+	const pipeline = createPipelineFromOptions$1(options);
+	pipeline.addPolicy(apiVersionPolicy(options));
+	addCredentialPipelinePolicy(pipeline, endpoint, {
+		credential,
+		clientOptions: options
+	});
+	return pipeline;
+}
+function isKeyCredential(credential) {
+	return credential.key !== void 0;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@azure-rest+core-client@2.5.1/node_modules/@azure-rest/core-client/dist/esm/getClient.js
+/**
+* Function to wrap RequestParameters so that we get the legacy onResponse behavior in core-client-rest
+*/
+function wrapRequestParameters(parameters) {
+	if (parameters.onResponse) return {
+		...parameters,
+		onResponse(rawResponse, error) {
+			parameters.onResponse?.(rawResponse, error, error);
+		}
+	};
+	return parameters;
+}
+function getClient(endpoint, credentialsOrPipelineOptions, clientOptions = {}) {
+	let credentials;
+	if (credentialsOrPipelineOptions) if (isCredential(credentialsOrPipelineOptions)) credentials = credentialsOrPipelineOptions;
+	else clientOptions = credentialsOrPipelineOptions ?? {};
+	const pipeline = createDefaultPipeline(endpoint, credentials, clientOptions);
+	const tspClient = getClient$1(endpoint, {
+		...clientOptions,
+		pipeline
+	});
+	const client = (path, ...args) => {
+		return {
+			get: (requestOptions = {}) => {
+				return tspClient.path(path, ...args).get(wrapRequestParameters(requestOptions));
+			},
+			post: (requestOptions = {}) => {
+				return tspClient.path(path, ...args).post(wrapRequestParameters(requestOptions));
+			},
+			put: (requestOptions = {}) => {
+				return tspClient.path(path, ...args).put(wrapRequestParameters(requestOptions));
+			},
+			patch: (requestOptions = {}) => {
+				return tspClient.path(path, ...args).patch(wrapRequestParameters(requestOptions));
+			},
+			delete: (requestOptions = {}) => {
+				return tspClient.path(path, ...args).delete(wrapRequestParameters(requestOptions));
+			},
+			head: (requestOptions = {}) => {
+				return tspClient.path(path, ...args).head(wrapRequestParameters(requestOptions));
+			},
+			options: (requestOptions = {}) => {
+				return tspClient.path(path, ...args).options(wrapRequestParameters(requestOptions));
+			},
+			trace: (requestOptions = {}) => {
+				return tspClient.path(path, ...args).trace(wrapRequestParameters(requestOptions));
+			}
+		};
+	};
+	return {
+		path: client,
+		pathUnchecked: client,
+		pipeline: tspClient.pipeline
+	};
+}
+function isCredential(param) {
+	return isKeyCredential$1(param) || isTokenCredential(param);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+keyvault-secrets@4.10.0/node_modules/@azure/keyvault-secrets/dist/esm/generated/api/keyVaultContext.js
+/** The key vault client performs cryptographic key operations and vault operations against the Key Vault service. */
+function createKeyVault(endpointParam, credential, options = {}) {
+	var _a, _b, _c, _d, _e, _f, _g, _h;
+	const endpointUrl = (_b = (_a = options.endpoint) !== null && _a !== void 0 ? _a : options.baseUrl) !== null && _b !== void 0 ? _b : String(endpointParam);
+	const prefixFromOptions = (_c = options === null || options === void 0 ? void 0 : options.userAgentOptions) === null || _c === void 0 ? void 0 : _c.userAgentPrefix;
+	const userAgentInfo = `azsdk-js-keyvault-secrets/1.0.0-beta.1`;
+	const userAgentPrefix = prefixFromOptions ? `${prefixFromOptions} azsdk-js-api ${userAgentInfo}` : `azsdk-js-api ${userAgentInfo}`;
+	const _j = Object.assign(Object.assign({}, options), {
+		userAgentOptions: { userAgentPrefix },
+		loggingOptions: { logger: (_e = (_d = options.loggingOptions) === null || _d === void 0 ? void 0 : _d.logger) !== null && _e !== void 0 ? _e : logger$2.info },
+		credentials: { scopes: (_g = (_f = options.credentials) === null || _f === void 0 ? void 0 : _f.scopes) !== null && _g !== void 0 ? _g : ["https://vault.azure.net/.default"] }
+	}), { apiVersion: _ } = _j;
+	const clientContext = getClient(endpointUrl, credential, __rest(_j, ["apiVersion"]));
+	clientContext.pipeline.removePolicy({ name: "ApiVersionPolicy" });
+	const apiVersion = (_h = options.apiVersion) !== null && _h !== void 0 ? _h : "7.6";
+	clientContext.pipeline.addPolicy({
+		name: "ClientApiVersionPolicy",
+		sendRequest: (req, next) => {
+			const url = new URL(req.url);
+			if (!url.searchParams.get("api-version")) req.url = `${req.url}${Array.from(url.searchParams.keys()).length > 0 ? "&" : "?"}api-version=${apiVersion}`;
+			return next(req);
+		}
+	});
+	return Object.assign(Object.assign({}, clientContext), { apiVersion });
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+keyvault-secrets@4.10.0/node_modules/@azure/keyvault-secrets/dist/esm/generated/models/models.js
+function secretSetParametersSerializer(item) {
+	return {
+		value: item["value"],
+		tags: item["tags"],
+		contentType: item["contentType"],
+		attributes: !item["secretAttributes"] ? item["secretAttributes"] : secretAttributesSerializer(item["secretAttributes"])
+	};
+}
+function secretAttributesSerializer(item) {
+	return {
+		enabled: item["enabled"],
+		nbf: !item["notBefore"] ? item["notBefore"] : item["notBefore"].getTime() / 1e3 | 0,
+		exp: !item["expires"] ? item["expires"] : item["expires"].getTime() / 1e3 | 0
+	};
+}
+function secretAttributesDeserializer(item) {
+	return {
+		enabled: item["enabled"],
+		notBefore: !item["nbf"] ? item["nbf"] : /* @__PURE__ */ new Date(item["nbf"] * 1e3),
+		expires: !item["exp"] ? item["exp"] : /* @__PURE__ */ new Date(item["exp"] * 1e3),
+		created: !item["created"] ? item["created"] : /* @__PURE__ */ new Date(item["created"] * 1e3),
+		updated: !item["updated"] ? item["updated"] : /* @__PURE__ */ new Date(item["updated"] * 1e3),
+		recoverableDays: item["recoverableDays"],
+		recoveryLevel: item["recoveryLevel"]
+	};
+}
+/** Reflects the deletion recovery level currently in effect for secrets in the current vault. If it contains 'Purgeable', the secret can be permanently deleted by a privileged user; otherwise, only the system can purge the secret, at the end of the retention interval. */
+var KnownDeletionRecoveryLevel;
+(function(KnownDeletionRecoveryLevel) {
+	/** Denotes a vault state in which deletion is an irreversible operation, without the possibility for recovery. This level corresponds to no protection being available against a Delete operation; the data is irretrievably lost upon accepting a Delete operation at the entity level or higher (vault, resource group, subscription etc.) */
+	KnownDeletionRecoveryLevel["Purgeable"] = "Purgeable";
+	/** Denotes a vault state in which deletion is recoverable, and which also permits immediate and permanent deletion (i.e. purge). This level guarantees the recoverability of the deleted entity during the retention interval (90 days), unless a Purge operation is requested, or the subscription is cancelled. System wil permanently delete it after 90 days, if not recovered */
+	KnownDeletionRecoveryLevel["RecoverablePurgeable"] = "Recoverable+Purgeable";
+	/** Denotes a vault state in which deletion is recoverable without the possibility for immediate and permanent deletion (i.e. purge). This level guarantees the recoverability of the deleted entity during the retention interval (90 days) and while the subscription is still available. System wil permanently delete it after 90 days, if not recovered */
+	KnownDeletionRecoveryLevel["Recoverable"] = "Recoverable";
+	/** Denotes a vault and subscription state in which deletion is recoverable within retention interval (90 days), immediate and permanent deletion (i.e. purge) is not permitted, and in which the subscription itself  cannot be permanently canceled. System wil permanently delete it after 90 days, if not recovered */
+	KnownDeletionRecoveryLevel["RecoverableProtectedSubscription"] = "Recoverable+ProtectedSubscription";
+	/** Denotes a vault state in which deletion is recoverable, and which also permits immediate and permanent deletion (i.e. purge when 7 <= SoftDeleteRetentionInDays < 90). This level guarantees the recoverability of the deleted entity during the retention interval, unless a Purge operation is requested, or the subscription is cancelled. */
+	KnownDeletionRecoveryLevel["CustomizedRecoverablePurgeable"] = "CustomizedRecoverable+Purgeable";
+	/** Denotes a vault state in which deletion is recoverable without the possibility for immediate and permanent deletion (i.e. purge when 7 <= SoftDeleteRetentionInDays < 90).This level guarantees the recoverability of the deleted entity during the retention interval and while the subscription is still available. */
+	KnownDeletionRecoveryLevel["CustomizedRecoverable"] = "CustomizedRecoverable";
+	/** Denotes a vault and subscription state in which deletion is recoverable, immediate and permanent deletion (i.e. purge) is not permitted, and in which the subscription itself cannot be permanently canceled when 7 <= SoftDeleteRetentionInDays < 90. This level guarantees the recoverability of the deleted entity during the retention interval, and also reflects the fact that the subscription itself cannot be cancelled. */
+	KnownDeletionRecoveryLevel["CustomizedRecoverableProtectedSubscription"] = "CustomizedRecoverable+ProtectedSubscription";
+})(KnownDeletionRecoveryLevel || (KnownDeletionRecoveryLevel = {}));
+function secretBundleDeserializer(item) {
+	return {
+		value: item["value"],
+		id: item["id"],
+		contentType: item["contentType"],
+		attributes: !item["attributes"] ? item["attributes"] : secretAttributesDeserializer(item["attributes"]),
+		tags: item["tags"],
+		kid: item["kid"],
+		managed: item["managed"]
+	};
+}
+function keyVaultErrorDeserializer(item) {
+	return { error: !item["error"] ? item["error"] : _keyVaultErrorErrorDeserializer(item["error"]) };
+}
+function _keyVaultErrorErrorDeserializer(item) {
+	return {
+		code: item["code"],
+		message: item["message"],
+		innerError: !item["innererror"] ? item["innererror"] : _keyVaultErrorErrorDeserializer(item["innererror"])
+	};
+}
+function deletedSecretBundleDeserializer(item) {
+	return {
+		value: item["value"],
+		id: item["id"],
+		contentType: item["contentType"],
+		attributes: !item["attributes"] ? item["attributes"] : secretAttributesDeserializer(item["attributes"]),
+		tags: item["tags"],
+		kid: item["kid"],
+		managed: item["managed"],
+		recoveryId: item["recoveryId"],
+		scheduledPurgeDate: !item["scheduledPurgeDate"] ? item["scheduledPurgeDate"] : /* @__PURE__ */ new Date(item["scheduledPurgeDate"] * 1e3),
+		deletedDate: !item["deletedDate"] ? item["deletedDate"] : /* @__PURE__ */ new Date(item["deletedDate"] * 1e3)
+	};
+}
+function secretUpdateParametersSerializer(item) {
+	return {
+		contentType: item["contentType"],
+		attributes: !item["secretAttributes"] ? item["secretAttributes"] : secretAttributesSerializer(item["secretAttributes"]),
+		tags: item["tags"]
+	};
+}
+function _secretListResultDeserializer(item) {
+	return {
+		value: !item["value"] ? item["value"] : secretItemArrayDeserializer(item["value"]),
+		nextLink: item["nextLink"]
+	};
+}
+function secretItemArrayDeserializer(result) {
+	return result.map((item) => {
+		return secretItemDeserializer(item);
+	});
+}
+function secretItemDeserializer(item) {
+	return {
+		id: item["id"],
+		attributes: !item["attributes"] ? item["attributes"] : secretAttributesDeserializer(item["attributes"]),
+		tags: item["tags"],
+		contentType: item["contentType"],
+		managed: item["managed"]
+	};
+}
+function _deletedSecretListResultDeserializer(item) {
+	return {
+		value: !item["value"] ? item["value"] : deletedSecretItemArrayDeserializer(item["value"]),
+		nextLink: item["nextLink"]
+	};
+}
+function deletedSecretItemArrayDeserializer(result) {
+	return result.map((item) => {
+		return deletedSecretItemDeserializer(item);
+	});
+}
+function deletedSecretItemDeserializer(item) {
+	return {
+		id: item["id"],
+		attributes: !item["attributes"] ? item["attributes"] : secretAttributesDeserializer(item["attributes"]),
+		tags: item["tags"],
+		contentType: item["contentType"],
+		managed: item["managed"],
+		recoveryId: item["recoveryId"],
+		scheduledPurgeDate: !item["scheduledPurgeDate"] ? item["scheduledPurgeDate"] : /* @__PURE__ */ new Date(item["scheduledPurgeDate"] * 1e3),
+		deletedDate: !item["deletedDate"] ? item["deletedDate"] : /* @__PURE__ */ new Date(item["deletedDate"] * 1e3)
+	};
+}
+function backupSecretResultDeserializer(item) {
+	return { value: !item["value"] ? item["value"] : typeof item["value"] === "string" ? stringToUint8Array$1(item["value"], "base64url") : item["value"] };
+}
+function secretRestoreParametersSerializer(item) {
+	return { value: uint8ArrayToString$1(item["secretBundleBackup"], "base64url") };
+}
+/** The available API versions. */
+var KnownVersions;
+(function(KnownVersions) {
+	/** The 7.5 API version. */
+	KnownVersions["V75"] = "7.5";
+	/** The 7.6-preview.2 API version. */
+	KnownVersions["V76Preview2"] = "7.6-preview.2";
+	/** The 7.6 API version. */
+	KnownVersions["V76"] = "7.6";
+})(KnownVersions || (KnownVersions = {}));
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+keyvault-secrets@4.10.0/node_modules/@azure/keyvault-secrets/dist/esm/generated/static-helpers/pagingHelpers.js
+init_tslib_es6();
+/**
+* Helper to paginate results in a generic way and return a PagedAsyncIterableIterator
+*/
+function buildPagedAsyncIterator(client, getInitialResponse, processResponseBody, expectedStatuses, options = {}) {
+	var _a, _b;
+	const itemName = (_a = options.itemName) !== null && _a !== void 0 ? _a : "value";
+	const nextLinkName = (_b = options.nextLinkName) !== null && _b !== void 0 ? _b : "nextLink";
+	const pagedResult = {
+		getPage: async (pageLink) => {
+			const result = pageLink === void 0 ? await getInitialResponse() : await client.pathUnchecked(pageLink).get();
+			checkPagingRequest(result, expectedStatuses);
+			const results = await processResponseBody(result);
+			const nextLink = getNextLink(results, nextLinkName);
+			return {
+				page: getElements(results, itemName),
+				nextPageLink: nextLink
+			};
+		},
+		byPage: (settings) => {
+			const { continuationToken } = settings !== null && settings !== void 0 ? settings : {};
+			return getPageAsyncIterator(pagedResult, { pageLink: continuationToken });
+		}
+	};
+	return getPagedAsyncIterator(pagedResult);
+}
+/**
+* returns an async iterator that iterates over results. It also has a `byPage`
+* method that returns pages of items at once.
+*
+* @param pagedResult - an object that specifies how to get pages.
+* @returns a paged async iterator that iterates over results.
+*/
+function getPagedAsyncIterator(pagedResult) {
+	var _a;
+	const iter = getItemAsyncIterator(pagedResult);
+	return {
+		next() {
+			return iter.next();
+		},
+		[Symbol.asyncIterator]() {
+			return this;
+		},
+		byPage: (_a = pagedResult === null || pagedResult === void 0 ? void 0 : pagedResult.byPage) !== null && _a !== void 0 ? _a : ((settings) => {
+			const { continuationToken } = settings !== null && settings !== void 0 ? settings : {};
+			return getPageAsyncIterator(pagedResult, { pageLink: continuationToken });
+		})
+	};
+}
+function getItemAsyncIterator(pagedResult) {
+	return __asyncGenerator(this, arguments, function* getItemAsyncIterator_1() {
+		var _a, e_1, _b, _c;
+		const pages = getPageAsyncIterator(pagedResult);
+		try {
+			for (var _d = true, pages_1 = __asyncValues(pages), pages_1_1; pages_1_1 = yield __await(pages_1.next()), _a = pages_1_1.done, !_a; _d = true) {
+				_c = pages_1_1.value;
+				_d = false;
+				yield __await(yield* __asyncDelegator(__asyncValues(_c)));
+			}
+		} catch (e_1_1) {
+			e_1 = { error: e_1_1 };
+		} finally {
+			try {
+				if (!_d && !_a && (_b = pages_1.return)) yield __await(_b.call(pages_1));
+			} finally {
+				if (e_1) throw e_1.error;
+			}
+		}
+	});
+}
+function getPageAsyncIterator(pagedResult_1) {
+	return __asyncGenerator(this, arguments, function* getPageAsyncIterator_1(pagedResult, options = {}) {
+		const { pageLink } = options;
+		let response = yield __await(pagedResult.getPage(pageLink !== null && pageLink !== void 0 ? pageLink : pagedResult.firstPageLink));
+		if (!response) return yield __await(void 0);
+		let result = response.page;
+		result.continuationToken = response.nextPageLink;
+		yield yield __await(result);
+		while (response.nextPageLink) {
+			response = yield __await(pagedResult.getPage(response.nextPageLink));
+			if (!response) return yield __await(void 0);
+			result = response.page;
+			result.continuationToken = response.nextPageLink;
+			yield yield __await(result);
+		}
+	});
+}
+/**
+* Gets for the value of nextLink in the body
+*/
+function getNextLink(body, nextLinkName) {
+	if (!nextLinkName) return;
+	const nextLink = body[nextLinkName];
+	if (typeof nextLink !== "string" && typeof nextLink !== "undefined" && nextLink !== null) throw new RestError$1(`Body Property ${nextLinkName} should be a string or undefined or null but got ${typeof nextLink}`);
+	if (nextLink === null) return;
+	return nextLink;
+}
+/**
+* Gets the elements of the current request in the body.
+*/
+function getElements(body, itemName) {
+	const value = body[itemName];
+	if (!Array.isArray(value)) throw new RestError$1(`Couldn't paginate response\n Body doesn't contain an array property with name: ${itemName}`);
+	return value !== null && value !== void 0 ? value : [];
+}
+/**
+* Checks if a request failed
+*/
+function checkPagingRequest(response, expectedStatuses) {
+	if (!expectedStatuses.includes(response.status)) throw createRestError(`Pagination failed with unexpected statusCode ${response.status}`, response);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+keyvault-secrets@4.10.0/node_modules/@azure/keyvault-secrets/dist/esm/generated/static-helpers/urlTemplate.js
+function encodeComponent(val, reserved, op) {
+	return (reserved !== null && reserved !== void 0 ? reserved : op === "+") || op === "#" ? encodeReservedComponent(val) : encodeRFC3986URIComponent(val);
+}
+function encodeReservedComponent(str) {
+	return str.split(/(%[0-9A-Fa-f]{2})/g).map((part) => !/%[0-9A-Fa-f]/.test(part) ? encodeURI(part) : part).join("");
+}
+function encodeRFC3986URIComponent(str) {
+	return encodeURIComponent(str).replace(/[!'()*]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
+}
+function isDefined(val) {
+	return val !== void 0 && val !== null;
+}
+function getNamedAndIfEmpty(op) {
+	return [!!op && [
+		";",
+		"?",
+		"&"
+	].includes(op), !!op && ["?", "&"].includes(op) ? "=" : ""];
+}
+function getFirstOrSep(op, isFirst = false) {
+	if (isFirst) return !op || op === "+" ? "" : op;
+	else if (!op || op === "+" || op === "#") return ",";
+	else if (op === "?") return "&";
+	else return op;
+}
+function getExpandedValue(option) {
+	let isFirst = option.isFirst;
+	const { op, varName, varValue: value, reserved } = option;
+	const vals = [];
+	const [named, ifEmpty] = getNamedAndIfEmpty(op);
+	if (Array.isArray(value)) for (const val of value.filter(isDefined)) {
+		vals.push(`${getFirstOrSep(op, isFirst)}`);
+		if (named && varName) {
+			vals.push(`${encodeURIComponent(varName)}`);
+			val === "" ? vals.push(ifEmpty) : vals.push("=");
+		}
+		vals.push(encodeComponent(val, reserved, op));
+		isFirst = false;
+	}
+	else if (typeof value === "object") for (const key of Object.keys(value)) {
+		const val = value[key];
+		if (!isDefined(val)) continue;
+		vals.push(`${getFirstOrSep(op, isFirst)}`);
+		if (key) {
+			vals.push(`${encodeURIComponent(key)}`);
+			named && val === "" ? vals.push(ifEmpty) : vals.push("=");
+		}
+		vals.push(encodeComponent(val, reserved, op));
+		isFirst = false;
+	}
+	return vals.join("");
+}
+function getNonExpandedValue(option) {
+	const { op, varName, varValue: value, isFirst, reserved } = option;
+	const vals = [];
+	const first = getFirstOrSep(op, isFirst);
+	const [named, ifEmpty] = getNamedAndIfEmpty(op);
+	if (named && varName) {
+		vals.push(encodeComponent(varName, reserved, op));
+		if (value === "") {
+			if (!ifEmpty) vals.push(ifEmpty);
+			return !vals.join("") ? void 0 : `${first}${vals.join("")}`;
+		}
+		vals.push("=");
+	}
+	const items = [];
+	if (Array.isArray(value)) for (const val of value.filter(isDefined)) items.push(encodeComponent(val, reserved, op));
+	else if (typeof value === "object") for (const key of Object.keys(value)) {
+		if (!isDefined(value[key])) continue;
+		items.push(encodeRFC3986URIComponent(key));
+		items.push(encodeComponent(value[key], reserved, op));
+	}
+	vals.push(items.join(","));
+	return !vals.join(",") ? void 0 : `${first}${vals.join("")}`;
+}
+function getVarValue(option) {
+	const { op, varName, modifier, isFirst, reserved, varValue: value } = option;
+	if (!isDefined(value)) return;
+	else if ([
+		"string",
+		"number",
+		"boolean"
+	].includes(typeof value)) {
+		let val = value.toString();
+		const [named, ifEmpty] = getNamedAndIfEmpty(op);
+		const vals = [getFirstOrSep(op, isFirst)];
+		if (named && varName) {
+			vals.push(varName);
+			val === "" ? vals.push(ifEmpty) : vals.push("=");
+		}
+		if (modifier && modifier !== "*") val = val.substring(0, parseInt(modifier, 10));
+		vals.push(encodeComponent(val, reserved, op));
+		return vals.join("");
+	} else if (modifier === "*") return getExpandedValue(option);
+	else return getNonExpandedValue(option);
+}
+function expandUrlTemplate(template, context, option) {
+	return template.replace(/\{([^\{\}]+)\}|([^\{\}]+)/g, (_, expr, text) => {
+		if (!expr) return encodeReservedComponent(text);
+		let op;
+		if ([
+			"+",
+			"#",
+			".",
+			"/",
+			";",
+			"?",
+			"&"
+		].includes(expr[0])) op = expr[0], expr = expr.slice(1);
+		const varList = expr.split(/,/g);
+		const result = [];
+		for (const varSpec of varList) {
+			const varMatch = /([^:\*]*)(?::(\d+)|(\*))?/.exec(varSpec);
+			if (!varMatch || !varMatch[1]) continue;
+			const varValue = getVarValue({
+				isFirst: result.length === 0,
+				op,
+				varValue: context[varMatch[1]],
+				varName: varMatch[1],
+				modifier: varMatch[2] || varMatch[3],
+				reserved: option === null || option === void 0 ? void 0 : option.allowReserved
+			});
+			if (varValue) result.push(varValue);
+		}
+		return result.join("");
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+keyvault-secrets@4.10.0/node_modules/@azure/keyvault-secrets/dist/esm/generated/api/operations.js
+function _restoreSecretSend(context, parameters, options = { requestOptions: {} }) {
+	var _a, _b;
+	const path = expandUrlTemplate("/secrets/restore{?api%2Dversion}", { "api%2Dversion": context.apiVersion }, { allowReserved: (_a = options === null || options === void 0 ? void 0 : options.requestOptions) === null || _a === void 0 ? void 0 : _a.skipUrlEncoding });
+	return context.path(path).post(Object.assign(Object.assign({}, operationOptionsToRequestParameters(options)), {
+		contentType: "application/json",
+		headers: Object.assign({ accept: "application/json" }, (_b = options.requestOptions) === null || _b === void 0 ? void 0 : _b.headers),
+		body: secretRestoreParametersSerializer(parameters)
+	}));
+}
+async function _restoreSecretDeserialize(result) {
+	if (!["200"].includes(result.status)) {
+		const error = createRestError(result);
+		error.details = keyVaultErrorDeserializer(result.body);
+		throw error;
+	}
+	return secretBundleDeserializer(result.body);
+}
+/** Restores a backed up secret, and all its versions, to a vault. This operation requires the secrets/restore permission. */
+async function restoreSecret(context, parameters, options = { requestOptions: {} }) {
+	return _restoreSecretDeserialize(await _restoreSecretSend(context, parameters, options));
+}
+function _backupSecretSend(context, secretName, options = { requestOptions: {} }) {
+	var _a, _b;
+	const path = expandUrlTemplate("/secrets/{secret-name}/backup{?api%2Dversion}", {
+		"secret-name": secretName,
+		"api%2Dversion": context.apiVersion
+	}, { allowReserved: (_a = options === null || options === void 0 ? void 0 : options.requestOptions) === null || _a === void 0 ? void 0 : _a.skipUrlEncoding });
+	return context.path(path).post(Object.assign(Object.assign({}, operationOptionsToRequestParameters(options)), { headers: Object.assign({ accept: "application/json" }, (_b = options.requestOptions) === null || _b === void 0 ? void 0 : _b.headers) }));
+}
+async function _backupSecretDeserialize(result) {
+	if (!["200"].includes(result.status)) {
+		const error = createRestError(result);
+		error.details = keyVaultErrorDeserializer(result.body);
+		throw error;
+	}
+	return backupSecretResultDeserializer(result.body);
+}
+/** Requests that a backup of the specified secret be downloaded to the client. All versions of the secret will be downloaded. This operation requires the secrets/backup permission. */
+async function backupSecret(context, secretName, options = { requestOptions: {} }) {
+	return _backupSecretDeserialize(await _backupSecretSend(context, secretName, options));
+}
+function _recoverDeletedSecretSend(context, secretName, options = { requestOptions: {} }) {
+	var _a, _b;
+	const path = expandUrlTemplate("/deletedsecrets/{secret-name}/recover{?api%2Dversion}", {
+		"secret-name": secretName,
+		"api%2Dversion": context.apiVersion
+	}, { allowReserved: (_a = options === null || options === void 0 ? void 0 : options.requestOptions) === null || _a === void 0 ? void 0 : _a.skipUrlEncoding });
+	return context.path(path).post(Object.assign(Object.assign({}, operationOptionsToRequestParameters(options)), { headers: Object.assign({ accept: "application/json" }, (_b = options.requestOptions) === null || _b === void 0 ? void 0 : _b.headers) }));
+}
+async function _recoverDeletedSecretDeserialize(result) {
+	if (!["200"].includes(result.status)) {
+		const error = createRestError(result);
+		error.details = keyVaultErrorDeserializer(result.body);
+		throw error;
+	}
+	return secretBundleDeserializer(result.body);
+}
+/** Recovers the deleted secret in the specified vault. This operation can only be performed on a soft-delete enabled vault. This operation requires the secrets/recover permission. */
+async function recoverDeletedSecret(context, secretName, options = { requestOptions: {} }) {
+	return _recoverDeletedSecretDeserialize(await _recoverDeletedSecretSend(context, secretName, options));
+}
+function _purgeDeletedSecretSend(context, secretName, options = { requestOptions: {} }) {
+	var _a, _b;
+	const path = expandUrlTemplate("/deletedsecrets/{secret-name}{?api%2Dversion}", {
+		"secret-name": secretName,
+		"api%2Dversion": context.apiVersion
+	}, { allowReserved: (_a = options === null || options === void 0 ? void 0 : options.requestOptions) === null || _a === void 0 ? void 0 : _a.skipUrlEncoding });
+	return context.path(path).delete(Object.assign(Object.assign({}, operationOptionsToRequestParameters(options)), { headers: Object.assign({ accept: "application/json" }, (_b = options.requestOptions) === null || _b === void 0 ? void 0 : _b.headers) }));
+}
+async function _purgeDeletedSecretDeserialize(result) {
+	if (!["204"].includes(result.status)) {
+		const error = createRestError(result);
+		error.details = keyVaultErrorDeserializer(result.body);
+		throw error;
+	}
+}
+/** The purge deleted secret operation removes the secret permanently, without the possibility of recovery. This operation can only be enabled on a soft-delete enabled vault. This operation requires the secrets/purge permission. */
+async function purgeDeletedSecret(context, secretName, options = { requestOptions: {} }) {
+	return _purgeDeletedSecretDeserialize(await _purgeDeletedSecretSend(context, secretName, options));
+}
+function _getDeletedSecretSend(context, secretName, options = { requestOptions: {} }) {
+	var _a, _b;
+	const path = expandUrlTemplate("/deletedsecrets/{secret-name}{?api%2Dversion}", {
+		"secret-name": secretName,
+		"api%2Dversion": context.apiVersion
+	}, { allowReserved: (_a = options === null || options === void 0 ? void 0 : options.requestOptions) === null || _a === void 0 ? void 0 : _a.skipUrlEncoding });
+	return context.path(path).get(Object.assign(Object.assign({}, operationOptionsToRequestParameters(options)), { headers: Object.assign({ accept: "application/json" }, (_b = options.requestOptions) === null || _b === void 0 ? void 0 : _b.headers) }));
+}
+async function _getDeletedSecretDeserialize(result) {
+	if (!["200"].includes(result.status)) {
+		const error = createRestError(result);
+		error.details = keyVaultErrorDeserializer(result.body);
+		throw error;
+	}
+	return deletedSecretBundleDeserializer(result.body);
+}
+/** The Get Deleted Secret operation returns the specified deleted secret along with its attributes. This operation requires the secrets/get permission. */
+async function getDeletedSecret(context, secretName, options = { requestOptions: {} }) {
+	return _getDeletedSecretDeserialize(await _getDeletedSecretSend(context, secretName, options));
+}
+function _getDeletedSecretsSend(context, options = { requestOptions: {} }) {
+	var _a, _b;
+	const path = expandUrlTemplate("/deletedsecrets{?api%2Dversion,maxresults}", {
+		"api%2Dversion": context.apiVersion,
+		maxresults: options === null || options === void 0 ? void 0 : options.maxresults
+	}, { allowReserved: (_a = options === null || options === void 0 ? void 0 : options.requestOptions) === null || _a === void 0 ? void 0 : _a.skipUrlEncoding });
+	return context.path(path).get(Object.assign(Object.assign({}, operationOptionsToRequestParameters(options)), { headers: Object.assign({ accept: "application/json" }, (_b = options.requestOptions) === null || _b === void 0 ? void 0 : _b.headers) }));
+}
+async function _getDeletedSecretsDeserialize(result) {
+	if (!["200"].includes(result.status)) {
+		const error = createRestError(result);
+		error.details = keyVaultErrorDeserializer(result.body);
+		throw error;
+	}
+	return _deletedSecretListResultDeserializer(result.body);
+}
+/** The Get Deleted Secrets operation returns the secrets that have been deleted for a vault enabled for soft-delete. This operation requires the secrets/list permission. */
+function getDeletedSecrets(context, options = { requestOptions: {} }) {
+	return buildPagedAsyncIterator(context, () => _getDeletedSecretsSend(context, options), _getDeletedSecretsDeserialize, ["200"], {
+		itemName: "value",
+		nextLinkName: "nextLink"
+	});
+}
+function _getSecretVersionsSend(context, secretName, options = { requestOptions: {} }) {
+	var _a, _b;
+	const path = expandUrlTemplate("/secrets/{secret-name}/versions{?api%2Dversion,maxresults}", {
+		"secret-name": secretName,
+		"api%2Dversion": context.apiVersion,
+		maxresults: options === null || options === void 0 ? void 0 : options.maxresults
+	}, { allowReserved: (_a = options === null || options === void 0 ? void 0 : options.requestOptions) === null || _a === void 0 ? void 0 : _a.skipUrlEncoding });
+	return context.path(path).get(Object.assign(Object.assign({}, operationOptionsToRequestParameters(options)), { headers: Object.assign({ accept: "application/json" }, (_b = options.requestOptions) === null || _b === void 0 ? void 0 : _b.headers) }));
+}
+async function _getSecretVersionsDeserialize(result) {
+	if (!["200"].includes(result.status)) {
+		const error = createRestError(result);
+		error.details = keyVaultErrorDeserializer(result.body);
+		throw error;
+	}
+	return _secretListResultDeserializer(result.body);
+}
+/** The full secret identifier and attributes are provided in the response. No values are returned for the secrets. This operations requires the secrets/list permission. */
+function getSecretVersions(context, secretName, options = { requestOptions: {} }) {
+	return buildPagedAsyncIterator(context, () => _getSecretVersionsSend(context, secretName, options), _getSecretVersionsDeserialize, ["200"], {
+		itemName: "value",
+		nextLinkName: "nextLink"
+	});
+}
+function _getSecretsSend(context, options = { requestOptions: {} }) {
+	var _a, _b;
+	const path = expandUrlTemplate("/secrets{?api%2Dversion,maxresults}", {
+		"api%2Dversion": context.apiVersion,
+		maxresults: options === null || options === void 0 ? void 0 : options.maxresults
+	}, { allowReserved: (_a = options === null || options === void 0 ? void 0 : options.requestOptions) === null || _a === void 0 ? void 0 : _a.skipUrlEncoding });
+	return context.path(path).get(Object.assign(Object.assign({}, operationOptionsToRequestParameters(options)), { headers: Object.assign({ accept: "application/json" }, (_b = options.requestOptions) === null || _b === void 0 ? void 0 : _b.headers) }));
+}
+async function _getSecretsDeserialize(result) {
+	if (!["200"].includes(result.status)) {
+		const error = createRestError(result);
+		error.details = keyVaultErrorDeserializer(result.body);
+		throw error;
+	}
+	return _secretListResultDeserializer(result.body);
+}
+/** The Get Secrets operation is applicable to the entire vault. However, only the base secret identifier and its attributes are provided in the response. Individual secret versions are not listed in the response. This operation requires the secrets/list permission. */
+function getSecrets(context, options = { requestOptions: {} }) {
+	return buildPagedAsyncIterator(context, () => _getSecretsSend(context, options), _getSecretsDeserialize, ["200"], {
+		itemName: "value",
+		nextLinkName: "nextLink"
+	});
+}
+function _getSecretSend(context, secretName, secretVersion, options = { requestOptions: {} }) {
+	var _a, _b;
+	const path = expandUrlTemplate("/secrets/{secret-name}/{secret-version}{?api%2Dversion}", {
+		"secret-name": secretName,
+		"secret-version": secretVersion,
+		"api%2Dversion": context.apiVersion
+	}, { allowReserved: (_a = options === null || options === void 0 ? void 0 : options.requestOptions) === null || _a === void 0 ? void 0 : _a.skipUrlEncoding });
+	return context.path(path).get(Object.assign(Object.assign({}, operationOptionsToRequestParameters(options)), { headers: Object.assign({ accept: "application/json" }, (_b = options.requestOptions) === null || _b === void 0 ? void 0 : _b.headers) }));
+}
+async function _getSecretDeserialize(result) {
+	if (!["200"].includes(result.status)) {
+		const error = createRestError(result);
+		error.details = keyVaultErrorDeserializer(result.body);
+		throw error;
+	}
+	return secretBundleDeserializer(result.body);
+}
+/** The GET operation is applicable to any secret stored in Azure Key Vault. This operation requires the secrets/get permission. */
+async function getSecret(context, secretName, secretVersion, options = { requestOptions: {} }) {
+	return _getSecretDeserialize(await _getSecretSend(context, secretName, secretVersion, options));
+}
+function _updateSecretSend(context, secretName, secretVersion, parameters, options = { requestOptions: {} }) {
+	var _a, _b;
+	const path = expandUrlTemplate("/secrets/{secret-name}/{secret-version}{?api%2Dversion}", {
+		"secret-name": secretName,
+		"secret-version": secretVersion,
+		"api%2Dversion": context.apiVersion
+	}, { allowReserved: (_a = options === null || options === void 0 ? void 0 : options.requestOptions) === null || _a === void 0 ? void 0 : _a.skipUrlEncoding });
+	return context.path(path).patch(Object.assign(Object.assign({}, operationOptionsToRequestParameters(options)), {
+		contentType: "application/json",
+		headers: Object.assign({ accept: "application/json" }, (_b = options.requestOptions) === null || _b === void 0 ? void 0 : _b.headers),
+		body: secretUpdateParametersSerializer(parameters)
+	}));
+}
+async function _updateSecretDeserialize(result) {
+	if (!["200"].includes(result.status)) {
+		const error = createRestError(result);
+		error.details = keyVaultErrorDeserializer(result.body);
+		throw error;
+	}
+	return secretBundleDeserializer(result.body);
+}
+/** The UPDATE operation changes specified attributes of an existing stored secret. Attributes that are not specified in the request are left unchanged. The value of a secret itself cannot be changed. This operation requires the secrets/set permission. */
+async function updateSecret(context, secretName, secretVersion, parameters, options = { requestOptions: {} }) {
+	return _updateSecretDeserialize(await _updateSecretSend(context, secretName, secretVersion, parameters, options));
+}
+function _deleteSecretSend(context, secretName, options = { requestOptions: {} }) {
+	var _a, _b;
+	const path = expandUrlTemplate("/secrets/{secret-name}{?api%2Dversion}", {
+		"secret-name": secretName,
+		"api%2Dversion": context.apiVersion
+	}, { allowReserved: (_a = options === null || options === void 0 ? void 0 : options.requestOptions) === null || _a === void 0 ? void 0 : _a.skipUrlEncoding });
+	return context.path(path).delete(Object.assign(Object.assign({}, operationOptionsToRequestParameters(options)), { headers: Object.assign({ accept: "application/json" }, (_b = options.requestOptions) === null || _b === void 0 ? void 0 : _b.headers) }));
+}
+async function _deleteSecretDeserialize(result) {
+	if (!["200"].includes(result.status)) {
+		const error = createRestError(result);
+		error.details = keyVaultErrorDeserializer(result.body);
+		throw error;
+	}
+	return deletedSecretBundleDeserializer(result.body);
+}
+/** The DELETE operation applies to any secret stored in Azure Key Vault. DELETE cannot be applied to an individual version of a secret. This operation requires the secrets/delete permission. */
+async function deleteSecret(context, secretName, options = { requestOptions: {} }) {
+	return _deleteSecretDeserialize(await _deleteSecretSend(context, secretName, options));
+}
+function _setSecretSend(context, secretName, parameters, options = { requestOptions: {} }) {
+	var _a, _b;
+	const path = expandUrlTemplate("/secrets/{secret-name}{?api%2Dversion}", {
+		"secret-name": secretName,
+		"api%2Dversion": context.apiVersion
+	}, { allowReserved: (_a = options === null || options === void 0 ? void 0 : options.requestOptions) === null || _a === void 0 ? void 0 : _a.skipUrlEncoding });
+	return context.path(path).put(Object.assign(Object.assign({}, operationOptionsToRequestParameters(options)), {
+		contentType: "application/json",
+		headers: Object.assign({ accept: "application/json" }, (_b = options.requestOptions) === null || _b === void 0 ? void 0 : _b.headers),
+		body: secretSetParametersSerializer(parameters)
+	}));
+}
+async function _setSecretDeserialize(result) {
+	if (!["200"].includes(result.status)) {
+		const error = createRestError(result);
+		error.details = keyVaultErrorDeserializer(result.body);
+		throw error;
+	}
+	return secretBundleDeserializer(result.body);
+}
+/** The SET operation adds a secret to the Azure Key Vault. If the named secret already exists, Azure Key Vault creates a new version of that secret. This operation requires the secrets/set permission. */
+async function setSecret(context, secretName, parameters, options = { requestOptions: {} }) {
+	return _setSecretDeserialize(await _setSecretSend(context, secretName, parameters, options));
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+keyvault-secrets@4.10.0/node_modules/@azure/keyvault-secrets/dist/esm/generated/keyVaultClient.js
+var KeyVaultClient = class {
+	/** The key vault client performs cryptographic key operations and vault operations against the Key Vault service. */
+	constructor(endpointParam, credential, options = {}) {
+		var _a;
+		const prefixFromOptions = (_a = options === null || options === void 0 ? void 0 : options.userAgentOptions) === null || _a === void 0 ? void 0 : _a.userAgentPrefix;
+		const userAgentPrefix = prefixFromOptions ? `${prefixFromOptions} azsdk-js-client` : `azsdk-js-client`;
+		this._client = createKeyVault(endpointParam, credential, Object.assign(Object.assign({}, options), { userAgentOptions: { userAgentPrefix } }));
+		this.pipeline = this._client.pipeline;
+	}
+	/** Restores a backed up secret, and all its versions, to a vault. This operation requires the secrets/restore permission. */
+	restoreSecret(parameters, options = { requestOptions: {} }) {
+		return restoreSecret(this._client, parameters, options);
+	}
+	/** Requests that a backup of the specified secret be downloaded to the client. All versions of the secret will be downloaded. This operation requires the secrets/backup permission. */
+	backupSecret(secretName, options = { requestOptions: {} }) {
+		return backupSecret(this._client, secretName, options);
+	}
+	/** Recovers the deleted secret in the specified vault. This operation can only be performed on a soft-delete enabled vault. This operation requires the secrets/recover permission. */
+	recoverDeletedSecret(secretName, options = { requestOptions: {} }) {
+		return recoverDeletedSecret(this._client, secretName, options);
+	}
+	/** The purge deleted secret operation removes the secret permanently, without the possibility of recovery. This operation can only be enabled on a soft-delete enabled vault. This operation requires the secrets/purge permission. */
+	purgeDeletedSecret(secretName, options = { requestOptions: {} }) {
+		return purgeDeletedSecret(this._client, secretName, options);
+	}
+	/** The Get Deleted Secret operation returns the specified deleted secret along with its attributes. This operation requires the secrets/get permission. */
+	getDeletedSecret(secretName, options = { requestOptions: {} }) {
+		return getDeletedSecret(this._client, secretName, options);
+	}
+	/** The Get Deleted Secrets operation returns the secrets that have been deleted for a vault enabled for soft-delete. This operation requires the secrets/list permission. */
+	getDeletedSecrets(options = { requestOptions: {} }) {
+		return getDeletedSecrets(this._client, options);
+	}
+	/** The full secret identifier and attributes are provided in the response. No values are returned for the secrets. This operations requires the secrets/list permission. */
+	getSecretVersions(secretName, options = { requestOptions: {} }) {
+		return getSecretVersions(this._client, secretName, options);
+	}
+	/** The Get Secrets operation is applicable to the entire vault. However, only the base secret identifier and its attributes are provided in the response. Individual secret versions are not listed in the response. This operation requires the secrets/list permission. */
+	getSecrets(options = { requestOptions: {} }) {
+		return getSecrets(this._client, options);
+	}
+	/** The GET operation is applicable to any secret stored in Azure Key Vault. This operation requires the secrets/get permission. */
+	getSecret(secretName, secretVersion, options = { requestOptions: {} }) {
+		return getSecret(this._client, secretName, secretVersion, options);
+	}
+	/** The UPDATE operation changes specified attributes of an existing stored secret. Attributes that are not specified in the request are left unchanged. The value of a secret itself cannot be changed. This operation requires the secrets/set permission. */
+	updateSecret(secretName, secretVersion, parameters, options = { requestOptions: {} }) {
+		return updateSecret(this._client, secretName, secretVersion, parameters, options);
+	}
+	/** The DELETE operation applies to any secret stored in Azure Key Vault. DELETE cannot be applied to an individual version of a secret. This operation requires the secrets/delete permission. */
+	deleteSecret(secretName, options = { requestOptions: {} }) {
+		return deleteSecret(this._client, secretName, options);
+	}
+	/** The SET operation adds a secret to the Azure Key Vault. If the named secret already exists, Azure Key Vault creates a new version of that secret. This operation requires the secrets/set permission. */
+	setSecret(secretName, parameters, options = { requestOptions: {} }) {
+		return setSecret(this._client, secretName, parameters, options);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+keyvault-common@2.0.0/node_modules/@azure/keyvault-common/dist/esm/parseWWWAuthenticate.js
+const validWWWAuthenticateProperties = [
+	"authorization",
+	"authorization_url",
+	"resource",
+	"scope",
+	"tenantId",
+	"claims",
+	"error"
+];
+/**
+* Parses an WWW-Authenticate response header.
+* This transforms a string value like:
+* `Bearer authorization="https://some.url/tenantId", resource="https://some.url"`
+* into an object like:
+* `{ authorization: "https://some.url/tenantId", resource: "https://some.url" }`
+* @param headerValue - String value in the WWW-Authenticate header
+*/
+function parseWWWAuthenticateHeader(headerValue) {
+	const parsed = headerValue.split(/,? +/).reduce((kvPairs, p) => {
+		if (p.match(/\w="/)) {
+			const [key, ...value] = p.split("=");
+			if (validWWWAuthenticateProperties.includes(key)) return Object.assign(Object.assign({}, kvPairs), { [key]: value.join("=").slice(1, -1) });
+		}
+		return kvPairs;
+	}, {});
+	if (parsed.authorization) try {
+		const tenantId = new URL(parsed.authorization).pathname.substring(1);
+		if (tenantId) parsed.tenantId = tenantId;
+	} catch (_) {
+		throw new Error(`The challenge authorization URI '${parsed.authorization}' is invalid.`);
+	}
+	return parsed;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+keyvault-common@2.0.0/node_modules/@azure/keyvault-common/dist/esm/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 (_a) {
+			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(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 = Object.assign(Object.assign({}, 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() {
+			var _a;
+			if (cycler.isRefreshing) return false;
+			if ((token === null || token === void 0 ? void 0 : token.refreshAfterTimestamp) && token.refreshAfterTimestamp < Date.now()) return true;
+			return ((_a = token === null || token === void 0 ? void 0 : token.expiresOnTimestamp) !== null && _a !== void 0 ? _a : 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) {
+		var _a;
+		if (!cycler.isRefreshing) {
+			const tryGetAccessToken = () => credential.getToken(scopes, getTokenOptions);
+			refreshWorker = beginRefresh(tryGetAccessToken, options.retryIntervalInMs, (_a = token === null || token === void 0 ? void 0 : token.expiresOnTimestamp) !== null && _a !== void 0 ? _a : 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+keyvault-common@2.0.0/node_modules/@azure/keyvault-common/dist/esm/logger.js
+const logger$1 = createClientLogger("keyvault-common");
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+keyvault-common@2.0.0/node_modules/@azure/keyvault-common/dist/esm/keyVaultAuthenticationPolicy.js
+function verifyChallengeResource(scope, request) {
+	let scopeAsUrl;
+	try {
+		scopeAsUrl = new URL(scope);
+	} catch (e) {
+		throw new Error(`The challenge contains invalid scope '${scope}'`);
+	}
+	if (!new URL(request.url).hostname.endsWith(`.${scopeAsUrl.hostname}`)) throw new Error(`The challenge resource '${scopeAsUrl.hostname}' does not match the requested domain. Set disableChallengeResourceVerification to true in your client options to disable. See https://aka.ms/azsdk/blog/vault-uri for more information.`);
+}
+/**
+* Name of the Key Vault authentication policy.
+*/
+const keyVaultAuthenticationPolicyName = "keyVaultAuthenticationPolicy";
+/**
+* A custom implementation of the bearer-token authentication policy that handles Key Vault and CAE challenges.
+*
+* Key Vault supports other authentication schemes, but we ensure challenge authentication
+* is used by first sending a copy of the request, without authorization or content.
+*
+* when the challenge is received, it will be authenticated and used to send the original
+* request with authorization.
+*
+* Following the first request of a client, follow-up requests will get the cached token
+* if possible.
+*
+*/
+function keyVaultAuthenticationPolicy(credential, options = {}) {
+	const { disableChallengeResourceVerification } = options;
+	let challengeState = { status: "none" };
+	const getAccessToken = createTokenCycler(credential);
+	function requestToOptions(request) {
+		return {
+			abortSignal: request.abortSignal,
+			requestOptions: { timeout: request.timeout > 0 ? request.timeout : void 0 },
+			tracingOptions: request.tracingOptions
+		};
+	}
+	async function authorizeRequest(request) {
+		const requestOptions = requestToOptions(request);
+		switch (challengeState.status) {
+			case "none":
+				challengeState = {
+					status: "started",
+					originalBody: request.body
+				};
+				request.body = null;
+				break;
+			case "started": break;
+			case "complete": {
+				const token = await getAccessToken(challengeState.scopes, Object.assign(Object.assign({}, requestOptions), {
+					enableCae: true,
+					tenantId: challengeState.tenantId
+				}));
+				if (token) request.headers.set("authorization", `Bearer ${token.token}`);
+				break;
+			}
+		}
+	}
+	async function handleChallenge(request, response, next) {
+		if (response.status !== 401) return response;
+		if (request.body === null && challengeState.status === "started") request.body = challengeState.originalBody;
+		const getTokenOptions = requestToOptions(request);
+		const challenge = response.headers.get("WWW-Authenticate");
+		if (!challenge) {
+			logger$1.warning("keyVaultAuthentication policy encountered a 401 response without a corresponding WWW-Authenticate header. This is unexpected. Not handling the 401 response.");
+			return response;
+		}
+		const parsedChallenge = parseWWWAuthenticateHeader(challenge);
+		const scope = parsedChallenge.resource ? parsedChallenge.resource + "/.default" : parsedChallenge.scope;
+		if (!scope) return response;
+		if (!disableChallengeResourceVerification) verifyChallengeResource(scope, request);
+		const accessToken = await getAccessToken([scope], Object.assign(Object.assign({}, getTokenOptions), {
+			enableCae: true,
+			tenantId: parsedChallenge.tenantId
+		}));
+		if (!accessToken) return response;
+		request.headers.set("Authorization", `Bearer ${accessToken.token}`);
+		challengeState = {
+			status: "complete",
+			scopes: [scope],
+			tenantId: parsedChallenge.tenantId
+		};
+		return next(request);
+	}
+	async function handleCaeChallenge(request, response, next) {
+		if (challengeState.status !== "complete") return response;
+		if (response.status !== 401) return response;
+		const getTokenOptions = requestToOptions(request);
+		const challenge = response.headers.get("WWW-Authenticate");
+		if (!challenge) return response;
+		const { claims: base64EncodedClaims, error } = parseWWWAuthenticateHeader(challenge);
+		if (error !== "insufficient_claims" || base64EncodedClaims === void 0) return response;
+		const claims = atob(base64EncodedClaims);
+		const accessToken = await getAccessToken(challengeState.scopes, Object.assign(Object.assign({}, getTokenOptions), {
+			enableCae: true,
+			tenantId: challengeState.tenantId,
+			claims
+		}));
+		request.headers.set("Authorization", `Bearer ${accessToken.token}`);
+		return next(request);
+	}
+	async function sendRequest(request, next) {
+		await authorizeRequest(request);
+		let response = await next(request);
+		response = await handleChallenge(request, response, next);
+		response = await handleCaeChallenge(request, response, next);
+		return response;
+	}
+	return {
+		name: keyVaultAuthenticationPolicyName,
+		sendRequest
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+keyvault-common@2.0.0/node_modules/@azure/keyvault-common/dist/esm/parseKeyVaultIdentifier.js
+/**
+* Parses a Key Vault identifier into its components.
+*
+* @param collection - The collection of the Key Vault identifier.
+* @param identifier - The Key Vault identifier to be parsed.
+*/
+function parseKeyVaultIdentifier(collection, identifier) {
+	if (typeof collection !== "string" || !(collection = collection.trim())) throw new Error("Invalid collection argument");
+	if (typeof identifier !== "string" || !(identifier = identifier.trim())) throw new Error("Invalid identifier argument");
+	let baseUri;
+	try {
+		baseUri = new URL(identifier);
+	} catch (e) {
+		throw new Error(`Invalid ${collection} identifier: ${identifier}. Not a valid URI`);
+	}
+	const segments = (baseUri.pathname || "").split("/");
+	if (segments.length !== 3 && segments.length !== 4) throw new Error(`Invalid ${collection} identifier: ${identifier}. Bad number of segments: ${segments.length}`);
+	if (collection !== segments[1]) throw new Error(`Invalid ${collection} identifier: ${identifier}. segment [1] should be "${collection}", found "${segments[1]}"`);
+	return {
+		vaultUrl: `${baseUri.protocol}//${baseUri.host}`,
+		name: segments[2],
+		version: segments.length === 4 ? segments[3] : void 0
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+keyvault-secrets@4.10.0/node_modules/@azure/keyvault-secrets/dist/esm/identifier.js
+/**
+* Parses the given Key Vault Secret Id. An example is:
+*
+*   https://<keyvault-name>.vault.azure.net/secrets/<secret-name>/<unique-version-id>
+*
+* On parsing the above Id, this function returns:
+*```ts snippet:ignore
+*   {
+*      sourceId: "https://<keyvault-name>.vault.azure.net/secrets/<secret-name>/<unique-version-id>",
+*      vaultUrl: "https://<keyvault-name>.vault.azure.net",
+*      version: "<unique-version-id>",
+*      name: "<secret-name>"
+*   }
+*```
+* @param id - The Id of the Key Vault Secret.
+*/
+function parseKeyVaultSecretIdentifier(id) {
+	const collection = id.split("/")[3];
+	return Object.assign({ sourceId: id }, parseKeyVaultIdentifier(collection, id));
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+keyvault-secrets@4.10.0/node_modules/@azure/keyvault-secrets/dist/esm/transformations.js
+init_tslib_es6();
+/**
+* @internal
+* Shapes the exposed {@link KeyVaultKey} based on either a received secret bundle or deleted secret bundle.
+*/
+function getSecretFromSecretBundle(bundle) {
+	const secretBundle = bundle;
+	const deletedSecretBundle = bundle;
+	const parsedId = parseKeyVaultSecretIdentifier(secretBundle.id);
+	const attributes = secretBundle.attributes;
+	delete secretBundle.attributes;
+	const resultObject = {
+		value: secretBundle.value,
+		name: parsedId.name,
+		properties: {
+			expiresOn: attributes === null || attributes === void 0 ? void 0 : attributes.expires,
+			createdOn: attributes === null || attributes === void 0 ? void 0 : attributes.created,
+			updatedOn: attributes === null || attributes === void 0 ? void 0 : attributes.updated,
+			enabled: attributes === null || attributes === void 0 ? void 0 : attributes.enabled,
+			notBefore: attributes === null || attributes === void 0 ? void 0 : attributes.notBefore,
+			recoverableDays: attributes === null || attributes === void 0 ? void 0 : attributes.recoverableDays,
+			recoveryLevel: attributes === null || attributes === void 0 ? void 0 : attributes.recoveryLevel,
+			id: secretBundle.id,
+			contentType: secretBundle.contentType,
+			tags: secretBundle.tags,
+			managed: secretBundle.managed,
+			vaultUrl: parsedId.vaultUrl,
+			version: parsedId.version,
+			name: parsedId.name,
+			certificateKeyId: secretBundle.kid
+		}
+	};
+	if (deletedSecretBundle.recoveryId) {
+		resultObject.properties.recoveryId = deletedSecretBundle.recoveryId;
+		resultObject.properties.scheduledPurgeDate = deletedSecretBundle.scheduledPurgeDate;
+		resultObject.properties.deletedOn = deletedSecretBundle.deletedDate;
+		resultObject.recoveryId = deletedSecretBundle.recoveryId;
+		resultObject.scheduledPurgeDate = deletedSecretBundle.scheduledPurgeDate;
+		resultObject.deletedOn = deletedSecretBundle.deletedDate;
+	}
+	if (attributes) {
+		if (attributes.vaultUrl) delete resultObject.properties.vaultUrl;
+		if (attributes.expires) delete resultObject.properties.expires;
+		if (attributes.created) delete resultObject.properties.created;
+		if (attributes.updated) delete resultObject.properties.updated;
+	}
+	return resultObject;
+}
+/**
+* A helper supporting compatibility between modular and legacy paged async iterables.
+*
+* Provides the following compatibility:
+* 1. Maps the values of the paged async iterable using the provided mapper function.
+* 2. Supports `maxPageSize` operation on the paged async iterable.
+*
+* TODO: move this to keyvault-common once everything is merged
+*/
+function mapPagedAsyncIterable(operation, operationOptions, mapper) {
+	let iter = void 0;
+	return {
+		async next() {
+			iter !== null && iter !== void 0 || (iter = operation(Object.assign(Object.assign({}, operationOptions), { maxresults: void 0 })));
+			const result = await iter.next();
+			return Object.assign(Object.assign({}, result), { value: result.value && mapper(result.value) });
+		},
+		[Symbol.asyncIterator]() {
+			return this;
+		},
+		byPage(settings) {
+			return __asyncGenerator(this, arguments, function* byPage_1() {
+				var _a, e_1, _b, _c;
+				const iteratorByPage = operation(Object.assign(Object.assign({}, operationOptions), { maxresults: settings === null || settings === void 0 ? void 0 : settings.maxPageSize })).byPage(settings);
+				try {
+					for (var _d = true, iteratorByPage_1 = __asyncValues(iteratorByPage), iteratorByPage_1_1; iteratorByPage_1_1 = yield __await(iteratorByPage_1.next()), _a = iteratorByPage_1_1.done, !_a; _d = true) {
+						_c = iteratorByPage_1_1.value;
+						_d = false;
+						yield yield __await(_c.map(mapper));
+					}
+				} catch (e_1_1) {
+					e_1 = { error: e_1_1 };
+				} finally {
+					try {
+						if (!_d && !_a && (_b = iteratorByPage_1.return)) yield __await(_b.call(iteratorByPage_1));
+					} finally {
+						if (e_1) throw e_1.error;
+					}
+				}
+			});
+		}
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+keyvault-secrets@4.10.0/node_modules/@azure/keyvault-secrets/dist/esm/constants.js
+const SDK_VERSION = "4.10.0";
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+keyvault-secrets@4.10.0/node_modules/@azure/keyvault-secrets/dist/esm/tracing.js
+const tracingClient = createTracingClient({
+	namespace: "Microsoft.KeyVault",
+	packageName: "@azure/keyvault-secrets",
+	packageVersion: SDK_VERSION
+});
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+core-lro@2.7.2/node_modules/@azure/core-lro/dist/esm/legacy/poller.js
+/**
+* When a poller is manually stopped through the `stopPolling` method,
+* the poller will be rejected with an instance of the PollerStoppedError.
+*/
+var PollerStoppedError = class PollerStoppedError extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "PollerStoppedError";
+		Object.setPrototypeOf(this, PollerStoppedError.prototype);
+	}
+};
+/**
+* When the operation is cancelled, the poller will be rejected with an instance
+* of the PollerCancelledError.
+*/
+var PollerCancelledError = class PollerCancelledError extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "PollerCancelledError";
+		Object.setPrototypeOf(this, PollerCancelledError.prototype);
+	}
+};
+/**
+* A class that represents the definition of a program that polls through consecutive requests
+* until it reaches a state of completion.
+*
+* A poller can be executed manually, by polling request by request by calling to the `poll()` method repeatedly, until its operation is completed.
+* It also provides a way to wait until the operation completes, by calling `pollUntilDone()` and waiting until the operation finishes.
+* Pollers can also request the cancellation of the ongoing process to whom is providing the underlying long running operation.
+*
+* ```ts
+* const poller = new MyPoller();
+*
+* // Polling just once:
+* await poller.poll();
+*
+* // We can try to cancel the request here, by calling:
+* //
+* //     await poller.cancelOperation();
+* //
+*
+* // Getting the final result:
+* const result = await poller.pollUntilDone();
+* ```
+*
+* The Poller is defined by two types, a type representing the state of the poller, which
+* must include a basic set of properties from `PollOperationState<TResult>`,
+* and a return type defined by `TResult`, which can be anything.
+*
+* The Poller class implements the `PollerLike` interface, which allows poller implementations to avoid having
+* to export the Poller's class directly, and instead only export the already instantiated poller with the PollerLike type.
+*
+* ```ts
+* class Client {
+*   public async makePoller: PollerLike<MyOperationState, MyResult> {
+*     const poller = new MyPoller({});
+*     // It might be preferred to return the poller after the first request is made,
+*     // so that some information can be obtained right away.
+*     await poller.poll();
+*     return poller;
+*   }
+* }
+*
+* const poller: PollerLike<MyOperationState, MyResult> = myClient.makePoller();
+* ```
+*
+* A poller can be created through its constructor, then it can be polled until it's completed.
+* At any point in time, the state of the poller can be obtained without delay through the getOperationState method.
+* At any point in time, the intermediate forms of the result type can be requested without delay.
+* Once the underlying operation is marked as completed, the poller will stop and the final value will be returned.
+*
+* ```ts
+* const poller = myClient.makePoller();
+* const state: MyOperationState = poller.getOperationState();
+*
+* // The intermediate result can be obtained at any time.
+* const result: MyResult | undefined = poller.getResult();
+*
+* // The final result can only be obtained after the poller finishes.
+* const result: MyResult = await poller.pollUntilDone();
+* ```
+*
+*/
+var Poller = class {
+	/**
+	* A poller needs to be initialized by passing in at least the basic properties of the `PollOperation<TState, TResult>`.
+	*
+	* When writing an implementation of a Poller, this implementation needs to deal with the initialization
+	* of any custom state beyond the basic definition of the poller. The basic poller assumes that the poller's
+	* operation has already been defined, at least its basic properties. The code below shows how to approach
+	* the definition of the constructor of a new custom poller.
+	*
+	* ```ts
+	* export class MyPoller extends Poller<MyOperationState, string> {
+	*   constructor({
+	*     // Anything you might need outside of the basics
+	*   }) {
+	*     let state: MyOperationState = {
+	*       privateProperty: private,
+	*       publicProperty: public,
+	*     };
+	*
+	*     const operation = {
+	*       state,
+	*       update,
+	*       cancel,
+	*       toString
+	*     }
+	*
+	*     // Sending the operation to the parent's constructor.
+	*     super(operation);
+	*
+	*     // You can assign more local properties here.
+	*   }
+	* }
+	* ```
+	*
+	* Inside of this constructor, a new promise is created. This will be used to
+	* tell the user when the poller finishes (see `pollUntilDone()`). The promise's
+	* resolve and reject methods are also used internally to control when to resolve
+	* or reject anyone waiting for the poller to finish.
+	*
+	* The constructor of a custom implementation of a poller is where any serialized version of
+	* a previous poller's operation should be deserialized into the operation sent to the
+	* base constructor. For example:
+	*
+	* ```ts
+	* export class MyPoller extends Poller<MyOperationState, string> {
+	*   constructor(
+	*     baseOperation: string | undefined
+	*   ) {
+	*     let state: MyOperationState = {};
+	*     if (baseOperation) {
+	*       state = {
+	*         ...JSON.parse(baseOperation).state,
+	*         ...state
+	*       };
+	*     }
+	*     const operation = {
+	*       state,
+	*       // ...
+	*     }
+	*     super(operation);
+	*   }
+	* }
+	* ```
+	*
+	* @param operation - Must contain the basic properties of `PollOperation<State, TResult>`.
+	*/
+	constructor(operation) {
+		/** controls whether to throw an error if the operation failed or was canceled. */
+		this.resolveOnUnsuccessful = false;
+		this.stopped = true;
+		this.pollProgressCallbacks = [];
+		this.operation = operation;
+		this.promise = new Promise((resolve, reject) => {
+			this.resolve = resolve;
+			this.reject = reject;
+		});
+		this.promise.catch(() => {});
+	}
+	/**
+	* Starts a loop that will break only if the poller is done
+	* or if the poller is stopped.
+	*/
+	async startPolling(pollOptions = {}) {
+		if (this.stopped) this.stopped = false;
+		while (!this.isStopped() && !this.isDone()) {
+			await this.poll(pollOptions);
+			await this.delay();
+		}
+	}
+	/**
+	* pollOnce does one polling, by calling to the update method of the underlying
+	* poll operation to make any relevant change effective.
+	*
+	* It only optionally receives an object with an abortSignal property, from \@azure/abort-controller's AbortSignalLike.
+	*
+	* @param options - Optional properties passed to the operation's update method.
+	*/
+	async pollOnce(options = {}) {
+		if (!this.isDone()) this.operation = await this.operation.update({
+			abortSignal: options.abortSignal,
+			fireProgress: this.fireProgress.bind(this)
+		});
+		this.processUpdatedState();
+	}
+	/**
+	* fireProgress calls the functions passed in via onProgress the method of the poller.
+	*
+	* It loops over all of the callbacks received from onProgress, and executes them, sending them
+	* the current operation state.
+	*
+	* @param state - The current operation state.
+	*/
+	fireProgress(state) {
+		for (const callback of this.pollProgressCallbacks) callback(state);
+	}
+	/**
+	* Invokes the underlying operation's cancel method.
+	*/
+	async cancelOnce(options = {}) {
+		this.operation = await this.operation.cancel(options);
+	}
+	/**
+	* Returns a promise that will resolve once a single polling request finishes.
+	* It does this by calling the update method of the Poller's operation.
+	*
+	* It only optionally receives an object with an abortSignal property, from \@azure/abort-controller's AbortSignalLike.
+	*
+	* @param options - Optional properties passed to the operation's update method.
+	*/
+	poll(options = {}) {
+		if (!this.pollOncePromise) {
+			this.pollOncePromise = this.pollOnce(options);
+			const clearPollOncePromise = () => {
+				this.pollOncePromise = void 0;
+			};
+			this.pollOncePromise.then(clearPollOncePromise, clearPollOncePromise).catch(this.reject);
+		}
+		return this.pollOncePromise;
+	}
+	processUpdatedState() {
+		if (this.operation.state.error) {
+			this.stopped = true;
+			if (!this.resolveOnUnsuccessful) {
+				this.reject(this.operation.state.error);
+				throw this.operation.state.error;
+			}
+		}
+		if (this.operation.state.isCancelled) {
+			this.stopped = true;
+			if (!this.resolveOnUnsuccessful) {
+				const error = new PollerCancelledError("Operation was canceled");
+				this.reject(error);
+				throw error;
+			}
+		}
+		if (this.isDone() && this.resolve) this.resolve(this.getResult());
+	}
+	/**
+	* Returns a promise that will resolve once the underlying operation is completed.
+	*/
+	async pollUntilDone(pollOptions = {}) {
+		if (this.stopped) this.startPolling(pollOptions).catch(this.reject);
+		this.processUpdatedState();
+		return this.promise;
+	}
+	/**
+	* Invokes the provided callback after each polling is completed,
+	* sending the current state of the poller's operation.
+	*
+	* It returns a method that can be used to stop receiving updates on the given callback function.
+	*/
+	onProgress(callback) {
+		this.pollProgressCallbacks.push(callback);
+		return () => {
+			this.pollProgressCallbacks = this.pollProgressCallbacks.filter((c) => c !== callback);
+		};
+	}
+	/**
+	* Returns true if the poller has finished polling.
+	*/
+	isDone() {
+		const state = this.operation.state;
+		return Boolean(state.isCompleted || state.isCancelled || state.error);
+	}
+	/**
+	* Stops the poller from continuing to poll.
+	*/
+	stopPolling() {
+		if (!this.stopped) {
+			this.stopped = true;
+			if (this.reject) this.reject(new PollerStoppedError("This poller is already stopped"));
+		}
+	}
+	/**
+	* Returns true if the poller is stopped.
+	*/
+	isStopped() {
+		return this.stopped;
+	}
+	/**
+	* Attempts to cancel the underlying operation.
+	*
+	* It only optionally receives an object with an abortSignal property, from \@azure/abort-controller's AbortSignalLike.
+	*
+	* If it's called again before it finishes, it will throw an error.
+	*
+	* @param options - Optional properties passed to the operation's update method.
+	*/
+	cancelOperation(options = {}) {
+		if (!this.cancelPromise) this.cancelPromise = this.cancelOnce(options);
+		else if (options.abortSignal) throw new Error("A cancel request is currently pending");
+		return this.cancelPromise;
+	}
+	/**
+	* Returns the state of the operation.
+	*
+	* Even though TState will be the same type inside any of the methods of any extension of the Poller class,
+	* implementations of the pollers can customize what's shared with the public by writing their own
+	* version of the `getOperationState` method, and by defining two types, one representing the internal state of the poller
+	* and a public type representing a safe to share subset of the properties of the internal state.
+	* Their definition of getOperationState can then return their public type.
+	*
+	* Example:
+	*
+	* ```ts
+	* // Let's say we have our poller's operation state defined as:
+	* interface MyOperationState extends PollOperationState<ResultType> {
+	*   privateProperty?: string;
+	*   publicProperty?: string;
+	* }
+	*
+	* // To allow us to have a true separation of public and private state, we have to define another interface:
+	* interface PublicState extends PollOperationState<ResultType> {
+	*   publicProperty?: string;
+	* }
+	*
+	* // Then, we define our Poller as follows:
+	* export class MyPoller extends Poller<MyOperationState, ResultType> {
+	*   // ... More content is needed here ...
+	*
+	*   public getOperationState(): PublicState {
+	*     const state: PublicState = this.operation.state;
+	*     return {
+	*       // Properties from PollOperationState<TResult>
+	*       isStarted: state.isStarted,
+	*       isCompleted: state.isCompleted,
+	*       isCancelled: state.isCancelled,
+	*       error: state.error,
+	*       result: state.result,
+	*
+	*       // The only other property needed by PublicState.
+	*       publicProperty: state.publicProperty
+	*     }
+	*   }
+	* }
+	* ```
+	*
+	* You can see this in the tests of this repository, go to the file:
+	* `../test/utils/testPoller.ts`
+	* and look for the getOperationState implementation.
+	*/
+	getOperationState() {
+		return this.operation.state;
+	}
+	/**
+	* Returns the result value of the operation,
+	* regardless of the state of the poller.
+	* It can return undefined or an incomplete form of the final TResult value
+	* depending on the implementation.
+	*/
+	getResult() {
+		return this.operation.state.result;
+	}
+	/**
+	* Returns a serialized version of the poller's operation
+	* by invoking the operation's toString method.
+	*/
+	toString() {
+		return this.operation.toString();
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+keyvault-secrets@4.10.0/node_modules/@azure/keyvault-secrets/dist/esm/lro/keyVaultSecretPoller.js
+/**
+* Common properties and methods of the Key Vault Secret Pollers.
+*/
+var KeyVaultSecretPoller = class extends Poller {
+	constructor() {
+		super(...arguments);
+		/**
+		* Defines how much time the poller is going to wait before making a new request to the service.
+		*/
+		this.intervalInMs = 2e3;
+	}
+	/**
+	* The method used by the poller to wait before attempting to update its operation.
+	*/
+	async delay() {
+		return delay(this.intervalInMs);
+	}
+};
+/**
+* Common properties and methods of the Key Vault Secret Poller operations.
+*/
+var KeyVaultSecretPollOperation = class {
+	constructor(state, options = {}) {
+		this.state = state;
+		this.cancelMessage = "";
+		if (options.cancelMessage) this.cancelMessage = options.cancelMessage;
+	}
+	/**
+	* Meant to reach to the service and update the Poller operation.
+	* @param options - The optional parameters, which is only an abortSignal from \@azure/abort-controller
+	*/
+	async update() {
+		throw new Error("Operation not supported.");
+	}
+	/**
+	* Meant to reach to the service and cancel the Poller operation.
+	* @param options - The optional parameters, which is only an abortSignal from \@azure/abort-controller
+	*/
+	async cancel() {
+		throw new Error(this.cancelMessage);
+	}
+	/**
+	* Serializes the Poller operation.
+	*/
+	toString() {
+		return JSON.stringify({ state: this.state });
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+keyvault-secrets@4.10.0/node_modules/@azure/keyvault-secrets/dist/esm/lro/delete/operation.js
+/**
+* An interface representing a delete secret's poll operation
+*/
+var DeleteSecretPollOperation = class extends KeyVaultSecretPollOperation {
+	constructor(state, client, operationOptions = {}) {
+		super(state, { cancelMessage: "Canceling the deletion of a secret is not supported." });
+		this.state = state;
+		this.client = client;
+		this.operationOptions = operationOptions;
+	}
+	/**
+	* Sends a delete request for the given Key Vault Key's name to the Key Vault service.
+	* Since the Key Vault Key won't be immediately deleted, we have {@link beginDeleteKey}.
+	*/
+	deleteSecret(name, options = {}) {
+		return tracingClient.withSpan("DeleteSecretPoller.deleteSecret", options, async (updatedOptions) => {
+			return getSecretFromSecretBundle(await this.client.deleteSecret(name, updatedOptions));
+		});
+	}
+	/**
+	* The getDeletedSecret method returns the specified deleted secret along with its properties.
+	* This operation requires the secrets/get permission.
+	*/
+	getDeletedSecret(name, options = {}) {
+		return tracingClient.withSpan("DeleteSecretPoller.getDeletedSecret", options, async (updatedOptions) => {
+			return getSecretFromSecretBundle(await this.client.getDeletedSecret(name, updatedOptions));
+		});
+	}
+	/**
+	* Reaches to the service and updates the delete secret's poll operation.
+	*/
+	async update(options = {}) {
+		const state = this.state;
+		const { name } = state;
+		if (options.abortSignal) this.operationOptions.abortSignal = options.abortSignal;
+		if (!state.isStarted) {
+			const deletedSecret = await this.deleteSecret(name, this.operationOptions);
+			state.isStarted = true;
+			state.result = deletedSecret;
+			if (!deletedSecret.properties.recoveryId) state.isCompleted = true;
+		}
+		if (!state.isCompleted) try {
+			state.result = await this.getDeletedSecret(name, this.operationOptions);
+			state.isCompleted = true;
+		} catch (error) {
+			if (error.statusCode === 403) state.isCompleted = true;
+			else if (error.statusCode !== 404) {
+				state.error = error;
+				state.isCompleted = true;
+				throw error;
+			}
+		}
+		return this;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+keyvault-secrets@4.10.0/node_modules/@azure/keyvault-secrets/dist/esm/lro/delete/poller.js
+/**
+* Class that creates a poller that waits until a secret finishes being deleted.
+*/
+var DeleteSecretPoller = class extends KeyVaultSecretPoller {
+	constructor(options) {
+		const { client, name, operationOptions, intervalInMs = 2e3, resumeFrom } = options;
+		let state;
+		if (resumeFrom) state = JSON.parse(resumeFrom).state;
+		const operation = new DeleteSecretPollOperation(Object.assign(Object.assign({}, state), { name }), client, operationOptions);
+		super(operation);
+		this.intervalInMs = intervalInMs;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+keyvault-secrets@4.10.0/node_modules/@azure/keyvault-secrets/dist/esm/lro/recover/operation.js
+/**
+* An interface representing a delete secret's poll operation
+*/
+var RecoverDeletedSecretPollOperation = class extends KeyVaultSecretPollOperation {
+	constructor(state, client, options = {}) {
+		super(state, { cancelMessage: "Canceling the recovery of a deleted secret is not supported." });
+		this.state = state;
+		this.client = client;
+		this.options = options;
+	}
+	/**
+	* The getSecret method returns the specified secret along with its properties.
+	* This operation requires the secrets/get permission.
+	*/
+	getSecret(name, options = {}) {
+		return tracingClient.withSpan("RecoverDeletedSecretPoller.getSecret", options, async (updatedOptions) => {
+			return getSecretFromSecretBundle(await this.client.getSecret(name, options && options.version ? options.version : "", updatedOptions));
+		});
+	}
+	/**
+	* The recoverDeletedSecret method recovers the specified deleted secret along with its properties.
+	* This operation requires the secrets/recover permission.
+	*/
+	recoverDeletedSecret(name, options = {}) {
+		return tracingClient.withSpan("RecoverDeletedSecretPoller.recoverDeletedSecret", options, async (updatedOptions) => {
+			return getSecretFromSecretBundle(await this.client.recoverDeletedSecret(name, updatedOptions));
+		});
+	}
+	/**
+	* Reaches to the service and updates the delete secret's poll operation.
+	*/
+	async update(options = {}) {
+		const state = this.state;
+		const { name } = state;
+		if (options.abortSignal) this.options.abortSignal = options.abortSignal;
+		if (!state.isStarted) {
+			try {
+				state.result = (await this.getSecret(name, this.options)).properties;
+				state.isCompleted = true;
+			} catch (_a) {}
+			if (!state.isCompleted) {
+				state.result = (await this.recoverDeletedSecret(name, this.options)).properties;
+				state.isStarted = true;
+			}
+		}
+		if (!state.isCompleted) try {
+			state.result = (await this.getSecret(name, this.options)).properties;
+			state.isCompleted = true;
+		} catch (error) {
+			if (error.statusCode === 403) state.isCompleted = true;
+			else if (error.statusCode !== 404) {
+				state.error = error;
+				state.isCompleted = true;
+				throw error;
+			}
+		}
+		return this;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+keyvault-secrets@4.10.0/node_modules/@azure/keyvault-secrets/dist/esm/lro/recover/poller.js
+/**
+* Class that deletes a poller that waits until a secret finishes being deleted
+*/
+var RecoverDeletedSecretPoller = class extends KeyVaultSecretPoller {
+	constructor(options) {
+		const { client, name, operationOptions, intervalInMs = 2e3, resumeFrom } = options;
+		let state;
+		if (resumeFrom) state = JSON.parse(resumeFrom).state;
+		const operation = new RecoverDeletedSecretPollOperation(Object.assign(Object.assign({}, state), { name }), client, operationOptions);
+		super(operation);
+		this.intervalInMs = intervalInMs;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+keyvault-secrets@4.10.0/node_modules/@azure/keyvault-secrets/dist/esm/index.js
+init_tslib_es6();
+/**
+* The SecretClient provides methods to manage {@link KeyVaultSecret} in
+* the Azure Key Vault. The client supports creating, retrieving, updating,
+* deleting, purging, backing up, restoring and listing KeyVaultSecrets. The
+* client also supports listing {@link DeletedSecret} for a soft-delete enabled Azure
+* Key Vault.
+*/
+var SecretClient = class {
+	/**
+	* Creates an instance of SecretClient.
+	*
+	* Example usage:
+	* ```ts snippet:ReadmeSampleCreateClient
+	* import { DefaultAzureCredential } from "@azure/identity";
+	* import { SecretClient } from "@azure/keyvault-secrets";
+	*
+	* const credential = new DefaultAzureCredential();
+	*
+	* // Build the URL to reach your key vault
+	* const vaultName = "<YOUR KEYVAULT NAME>";
+	* const url = `https://${vaultName}.vault.azure.net`;
+	*
+	* // Lastly, create our keys client and connect to the service
+	* const client = new SecretClient(url, credential);
+	* ```
+	* @param vaultUrl - The base URL to the vault. You should validate that this URL references a valid Key Vault resource. See https://aka.ms/azsdk/blog/vault-uri for details.
+	* @param credential - An object that implements the `TokenCredential` interface used to authenticate requests to the service. Use the \@azure/identity package to create a credential that suits your needs.
+	* @param pipelineOptions - Pipeline options used to configure Key Vault API requests.
+	*                          Omit this parameter to use the default pipeline configuration.
+	*/
+	constructor(vaultUrl, credential, pipelineOptions = {}) {
+		var _a, _b;
+		this.vaultUrl = vaultUrl;
+		const internalPipelineOptions = Object.assign(Object.assign({}, pipelineOptions), {
+			userAgentOptions: { userAgentPrefix: `${(_b = (_a = pipelineOptions.userAgentOptions) === null || _a === void 0 ? void 0 : _a.userAgentPrefix) !== null && _b !== void 0 ? _b : ""} azsdk-js-keyvault-secrets/${SDK_VERSION}` },
+			apiVersion: pipelineOptions.serviceVersion || "7.6",
+			loggingOptions: {
+				logger: logger.info,
+				additionalAllowedHeaderNames: [
+					"x-ms-keyvault-region",
+					"x-ms-keyvault-network-info",
+					"x-ms-keyvault-service-version"
+				]
+			}
+		});
+		this.client = new KeyVaultClient(this.vaultUrl, credential, internalPipelineOptions);
+		this.client.pipeline.removePolicy({ name: bearerTokenAuthenticationPolicyName });
+		this.client.pipeline.addPolicy(keyVaultAuthenticationPolicy(credential, pipelineOptions), {});
+		this.client.pipeline.addPolicy({
+			name: "ContentTypePolicy",
+			sendRequest(request, next) {
+				var _a;
+				if (((_a = request.headers.get("Content-Type")) !== null && _a !== void 0 ? _a : "").startsWith("application/json")) request.headers.set("Content-Type", "application/json");
+				return next(request);
+			}
+		});
+	}
+	/**
+	* The setSecret method adds a secret or secret version to the Azure Key Vault. If the named secret
+	* already exists, Azure Key Vault creates a new version of that secret.
+	* This operation requires the secrets/set permission.
+	*
+	* Example usage:
+	* ```ts snippet:ReadmeSampleCreateSecret
+	* import { DefaultAzureCredential } from "@azure/identity";
+	* import { SecretClient } from "@azure/keyvault-secrets";
+	*
+	* const credential = new DefaultAzureCredential();
+	*
+	* const vaultName = "<YOUR KEYVAULT NAME>";
+	* const url = `https://${vaultName}.vault.azure.net`;
+	*
+	* const client = new SecretClient(url, credential);
+	*
+	* const secretName = "MySecretName";
+	*
+	* const result = await client.setSecret(secretName, "MySecretValue");
+	* console.log("result: ", result);
+	* ```
+	* Adds a secret in a specified key vault.
+	* @param secretName - The name of the secret.
+	* @param value - The value of the secret.
+	* @param options - The optional parameters.
+	*/
+	setSecret(secretName, value, options = {}) {
+		const { enabled, notBefore, expiresOn: expires, tags } = options, remainingOptions = __rest(options, [
+			"enabled",
+			"notBefore",
+			"expiresOn",
+			"tags"
+		]);
+		return tracingClient.withSpan("SecretClient.setSecret", remainingOptions, async (updatedOptions) => {
+			return getSecretFromSecretBundle(await this.client.setSecret(secretName, {
+				value,
+				secretAttributes: {
+					enabled,
+					notBefore,
+					expires
+				},
+				tags
+			}, updatedOptions));
+		});
+	}
+	/**
+	* Deletes a secret stored in Azure Key Vault.
+	* This function returns a Long Running Operation poller that allows you to wait indefinitely until the secret is deleted.
+	*
+	* This operation requires the secrets/delete permission.
+	*
+	* Example usage:
+	* ```ts snippet:ReadmeSampleDeleteSecret
+	* import { DefaultAzureCredential } from "@azure/identity";
+	* import { SecretClient } from "@azure/keyvault-secrets";
+	*
+	* const credential = new DefaultAzureCredential();
+	*
+	* const vaultName = "<YOUR KEYVAULT NAME>";
+	* const url = `https://${vaultName}.vault.azure.net`;
+	*
+	* const client = new SecretClient(url, credential);
+	*
+	* const secretName = "MySecretName";
+	*
+	* await client.beginDeleteSecret(secretName);
+	* ```
+	* Deletes a secret from a specified key vault.
+	* @param secretName - The name of the secret.
+	* @param options - The optional parameters.
+	*/
+	async beginDeleteSecret(name, options = {}) {
+		const poller = new DeleteSecretPoller(Object.assign(Object.assign({
+			name,
+			client: this.client
+		}, options), { operationOptions: options }));
+		await poller.poll();
+		return poller;
+	}
+	/**
+	* The updateSecret method changes specified attributes of an existing stored secret. Properties that
+	* are not specified in the request are left unchanged. The value of a secret itself cannot be
+	* changed. This operation requires the secrets/set permission.
+	*
+	* Example usage:
+	* ```ts snippet:ReadmeSampleUpdateSecretAttributes
+	* import { DefaultAzureCredential } from "@azure/identity";
+	* import { SecretClient } from "@azure/keyvault-secrets";
+	*
+	* const credential = new DefaultAzureCredential();
+	*
+	* const vaultName = "<YOUR KEYVAULT NAME>";
+	* const url = `https://${vaultName}.vault.azure.net`;
+	*
+	* const client = new SecretClient(url, credential);
+	*
+	* const secretName = "MySecretName";
+	*
+	* const result = await client.getSecret(secretName);
+	* await client.updateSecretProperties(secretName, result.properties.version, { enabled: false });
+	* ```
+	* Updates the attributes associated with a specified secret in a given key vault.
+	* @param secretName - The name of the secret.
+	* @param secretVersion - The version of the secret.
+	* @param options - The optional parameters.
+	*/
+	async updateSecretProperties(secretName, secretVersion, options = {}) {
+		const { enabled, notBefore, expiresOn: expires, tags } = options, remainingOptions = __rest(options, [
+			"enabled",
+			"notBefore",
+			"expiresOn",
+			"tags"
+		]);
+		return tracingClient.withSpan("SecretClient.updateSecretProperties", remainingOptions, async (updatedOptions) => {
+			return getSecretFromSecretBundle(await this.client.updateSecret(secretName, secretVersion, {
+				secretAttributes: {
+					enabled,
+					notBefore,
+					expires
+				},
+				tags
+			}, updatedOptions)).properties;
+		});
+	}
+	/**
+	* The getSecret method is applicable to any secret stored in Azure Key Vault. This operation requires
+	* the secrets/get permission.
+	*
+	* Example usage:
+	* ```ts snippet:ReadmeSampleGetSecret
+	* import { DefaultAzureCredential } from "@azure/identity";
+	* import { SecretClient } from "@azure/keyvault-secrets";
+	*
+	* const credential = new DefaultAzureCredential();
+	*
+	* const vaultName = "<YOUR KEYVAULT NAME>";
+	* const url = `https://${vaultName}.vault.azure.net`;
+	*
+	* const client = new SecretClient(url, credential);
+	*
+	* const secretName = "MySecretName";
+	*
+	* const latestSecret = await client.getSecret(secretName);
+	* console.log(`Latest version of the secret ${secretName}: `, latestSecret);
+	*
+	* const specificSecret = await client.getSecret(secretName, {
+	*   version: latestSecret.properties.version!,
+	* });
+	* console.log(
+	*   `The secret ${secretName} at the version ${latestSecret.properties.version!}: `,
+	*   specificSecret,
+	* );
+	* ```
+	* Get a specified secret from a given key vault.
+	* @param secretName - The name of the secret.
+	* @param options - The optional parameters.
+	*/
+	getSecret(secretName, options = {}) {
+		return tracingClient.withSpan("SecretClient.getSecret", options, async (updatedOptions) => {
+			return getSecretFromSecretBundle(await this.client.getSecret(secretName, options && options.version ? options.version : "", updatedOptions));
+		});
+	}
+	/**
+	* The getDeletedSecret method returns the specified deleted secret along with its attributes.
+	* This operation requires the secrets/get permission.
+	*
+	* Example usage:
+	* ```ts snippet:ReadmeSampleGetDeletedSecret
+	* import { DefaultAzureCredential } from "@azure/identity";
+	* import { SecretClient } from "@azure/keyvault-secrets";
+	*
+	* const credential = new DefaultAzureCredential();
+	*
+	* const vaultName = "<YOUR KEYVAULT NAME>";
+	* const url = `https://${vaultName}.vault.azure.net`;
+	*
+	* const client = new SecretClient(url, credential);
+	*
+	* const secretName = "MySecretName";
+	*
+	* const result = await client.getDeletedSecret("MyDeletedSecret");
+	* ```
+	* Gets the specified deleted secret.
+	* @param secretName - The name of the secret.
+	* @param options - The optional parameters.
+	*/
+	getDeletedSecret(secretName, options = {}) {
+		return tracingClient.withSpan("SecretClient.getDeletedSecret", options, async (updatedOptions) => {
+			return getSecretFromSecretBundle(await this.client.getDeletedSecret(secretName, updatedOptions));
+		});
+	}
+	/**
+	* The purge deleted secret operation removes the secret permanently, without the possibility of
+	* recovery. This operation can only be enabled on a soft-delete enabled vault. This operation
+	* requires the secrets/purge permission.
+	*
+	* Example usage:
+	* ```ts snippet:ReadmeSamplePurgeDeletedSecret
+	* import { DefaultAzureCredential } from "@azure/identity";
+	* import { SecretClient } from "@azure/keyvault-secrets";
+	*
+	* const credential = new DefaultAzureCredential();
+	*
+	* const vaultName = "<YOUR KEYVAULT NAME>";
+	* const url = `https://${vaultName}.vault.azure.net`;
+	*
+	* const client = new SecretClient(url, credential);
+	*
+	* const secretName = "MySecretName";
+	*
+	* const deletePoller = await client.beginDeleteSecret(secretName);
+	* await deletePoller.pollUntilDone();
+	*
+	* await client.purgeDeletedSecret(secretName);
+	* ```
+	* Permanently deletes the specified secret.
+	* @param secretName - The name of the secret.
+	* @param options - The optional parameters.
+	*/
+	purgeDeletedSecret(secretName, options = {}) {
+		return tracingClient.withSpan("SecretClient.purgeDeletedSecret", options, async (updatedOptions) => {
+			await this.client.purgeDeletedSecret(secretName, updatedOptions);
+		});
+	}
+	/**
+	* Recovers the deleted secret in the specified vault.
+	* This function returns a Long Running Operation poller that allows you to wait indefinitely until the secret is recovered.
+	*
+	* This operation requires the secrets/recover permission.
+	*
+	* Example usage:
+	* ```ts snippet:ReadmeSampleRecoverDeletedSecret
+	* import { DefaultAzureCredential } from "@azure/identity";
+	* import { SecretClient } from "@azure/keyvault-secrets";
+	*
+	* const credential = new DefaultAzureCredential();
+	*
+	* const vaultName = "<YOUR KEYVAULT NAME>";
+	* const url = `https://${vaultName}.vault.azure.net`;
+	*
+	* const client = new SecretClient(url, credential);
+	*
+	* const secretName = "MySecretName";
+	*
+	* const deletePoller = await client.beginDeleteSecret(secretName);
+	* await deletePoller.pollUntilDone();
+	*
+	* const recoverPoller = await client.beginRecoverDeletedSecret(secretName);
+	* const deletedSecret = await recoverPoller.pollUntilDone();
+	* console.log(deletedSecret);
+	* ```
+	* Recovers the deleted secret to the latest version.
+	* @param secretName - The name of the deleted secret.
+	* @param options - The optional parameters.
+	*/
+	async beginRecoverDeletedSecret(name, options = {}) {
+		const poller = new RecoverDeletedSecretPoller(Object.assign(Object.assign({
+			name,
+			client: this.client
+		}, options), { operationOptions: options }));
+		await poller.poll();
+		return poller;
+	}
+	/**
+	* Requests that a backup of the specified secret be downloaded to the client. All versions of the
+	* secret will be downloaded. This operation requires the secrets/backup permission.
+	*
+	* Example usage:
+	* ```ts snippet:ReadmeSampleBackupSecret
+	* import { DefaultAzureCredential } from "@azure/identity";
+	* import { SecretClient } from "@azure/keyvault-secrets";
+	*
+	* const credential = new DefaultAzureCredential();
+	*
+	* const vaultName = "<YOUR KEYVAULT NAME>";
+	* const url = `https://${vaultName}.vault.azure.net`;
+	*
+	* const client = new SecretClient(url, credential);
+	*
+	* const secretName = "MySecretName";
+	*
+	* const backupResult = await client.backupSecret(secretName);
+	* ```
+	* Backs up the specified secret.
+	* @param secretName - The name of the secret.
+	* @param options - The optional parameters.
+	*/
+	backupSecret(secretName, options = {}) {
+		return tracingClient.withSpan("SecretClient.backupSecret", options, async (updatedOptions) => {
+			return (await this.client.backupSecret(secretName, updatedOptions)).value;
+		});
+	}
+	/**
+	* Restores a backed up secret, and all its versions, to a vault. This operation requires the
+	* secrets/restore permission.
+	*
+	* Example usage:
+	* ```ts snippet:ReadmeSampleRestoreSecret
+	* import { DefaultAzureCredential } from "@azure/identity";
+	* import { SecretClient } from "@azure/keyvault-secrets";
+	*
+	* const credential = new DefaultAzureCredential();
+	*
+	* const vaultName = "<YOUR KEYVAULT NAME>";
+	* const url = `https://${vaultName}.vault.azure.net`;
+	*
+	* const client = new SecretClient(url, credential);
+	*
+	* const secretName = "MySecretName";
+	*
+	* const backupResult = await client.backupSecret(secretName);
+	*
+	* await client.restoreSecretBackup(backupResult);
+	* ```
+	* Restores a backed up secret to a vault.
+	* @param secretBundleBackup - The backup blob associated with a secret bundle.
+	* @param options - The optional parameters.
+	*/
+	restoreSecretBackup(secretBundleBackup, options = {}) {
+		return tracingClient.withSpan("SecretClient.restoreSecretBackup", options, async (updatedOptions) => {
+			return getSecretFromSecretBundle(await this.client.restoreSecret({ secretBundleBackup }, updatedOptions)).properties;
+		});
+	}
+	/**
+	* Iterates all versions of the given secret in the vault. The full secret identifier and attributes are provided
+	* in the response. No values are returned for the secrets. This operations requires the secrets/list permission.
+	*
+	* Example usage:
+	* ```ts snippet:ReadmeSampleListSecrets
+	* import { DefaultAzureCredential } from "@azure/identity";
+	* import { SecretClient } from "@azure/keyvault-secrets";
+	*
+	* const credential = new DefaultAzureCredential();
+	*
+	* const vaultName = "<YOUR KEYVAULT NAME>";
+	* const url = `https://${vaultName}.vault.azure.net`;
+	*
+	* const client = new SecretClient(url, credential);
+	*
+	* const secretName = "MySecretName";
+	*
+	* for await (const secretProperties of client.listPropertiesOfSecrets()) {
+	*   console.log("Secret properties: ", secretProperties);
+	* }
+	*
+	* for await (const deletedSecret of client.listDeletedSecrets()) {
+	*   console.log("Deleted secret: ", deletedSecret);
+	* }
+	*
+	* for await (const versionProperties of client.listPropertiesOfSecretVersions(secretName)) {
+	*   console.log("Version properties: ", versionProperties);
+	* }
+	* ```
+	* @param secretName - Name of the secret to fetch versions for.
+	* @param options - The optional parameters.
+	*/
+	listPropertiesOfSecretVersions(secretName, options = {}) {
+		return mapPagedAsyncIterable((updatedOptions) => this.client.getSecretVersions(secretName, updatedOptions), options, (item) => getSecretFromSecretBundle(item).properties);
+	}
+	/**
+	* Iterates the latest version of all secrets in the vault.  The full secret identifier and attributes are provided
+	* in the response. No values are returned for the secrets. This operations requires the secrets/list permission.
+	*
+	* Example usage:
+	* ```ts snippet:ReadmeSampleListSecrets
+	* import { DefaultAzureCredential } from "@azure/identity";
+	* import { SecretClient } from "@azure/keyvault-secrets";
+	*
+	* const credential = new DefaultAzureCredential();
+	*
+	* const vaultName = "<YOUR KEYVAULT NAME>";
+	* const url = `https://${vaultName}.vault.azure.net`;
+	*
+	* const client = new SecretClient(url, credential);
+	*
+	* const secretName = "MySecretName";
+	*
+	* for await (const secretProperties of client.listPropertiesOfSecrets()) {
+	*   console.log("Secret properties: ", secretProperties);
+	* }
+	*
+	* for await (const deletedSecret of client.listDeletedSecrets()) {
+	*   console.log("Deleted secret: ", deletedSecret);
+	* }
+	*
+	* for await (const versionProperties of client.listPropertiesOfSecretVersions(secretName)) {
+	*   console.log("Version properties: ", versionProperties);
+	* }
+	* ```
+	* List all secrets in the vault.
+	* @param options - The optional parameters.
+	*/
+	listPropertiesOfSecrets(options = {}) {
+		return mapPagedAsyncIterable(this.client.getSecrets.bind(this.client), options, (item) => getSecretFromSecretBundle(item).properties);
+	}
+	/**
+	* Iterates the deleted secrets in the vault.  The full secret identifier and attributes are provided
+	* in the response. No values are returned for the secrets. This operations requires the secrets/list permission.
+	*
+	* Example usage:
+	* ```ts snippet:ReadmeSampleListSecrets
+	* import { DefaultAzureCredential } from "@azure/identity";
+	* import { SecretClient } from "@azure/keyvault-secrets";
+	*
+	* const credential = new DefaultAzureCredential();
+	*
+	* const vaultName = "<YOUR KEYVAULT NAME>";
+	* const url = `https://${vaultName}.vault.azure.net`;
+	*
+	* const client = new SecretClient(url, credential);
+	*
+	* const secretName = "MySecretName";
+	*
+	* for await (const secretProperties of client.listPropertiesOfSecrets()) {
+	*   console.log("Secret properties: ", secretProperties);
+	* }
+	*
+	* for await (const deletedSecret of client.listDeletedSecrets()) {
+	*   console.log("Deleted secret: ", deletedSecret);
+	* }
+	*
+	* for await (const versionProperties of client.listPropertiesOfSecretVersions(secretName)) {
+	*   console.log("Version properties: ", versionProperties);
+	* }
+	* ```
+	* List all secrets in the vault.
+	* @param options - The optional parameters.
+	*/
+	listDeletedSecrets(options = {}) {
+		return mapPagedAsyncIterable(this.client.getDeletedSecrets.bind(this.client), options, getSecretFromSecretBundle);
+	}
+};
+//#endregion
+export { KnownDeletionRecoveryLevel, SecretClient, logger, parseKeyVaultSecretIdentifier };