@sanity/client 7.26.2 → 8.1.0

package/dist/index.node.js

@@ -0,0 +1,3264 @@
+import { t as require_dist } from "./dist-C9ExSk2R.js";
+import { a as ServerError, c as isHttpError, i as CorsOriginError, l as isQueryParseError, o as formatQueryParseError, r as ClientError, t as defineRequester } from "./request-SnMg7nUX.js";
+import { t as isRecord } from "./isRecord-Kfmt-nk-.js";
+import { isTimeoutError } from "get-it";
+import { debug } from "get-it/middleware";
+import { Observable, catchError, concat, defer, finalize, isObservable, lastValueFrom, map, merge, mergeMap, of, share, tap, throwError, timer } from "rxjs";
+import { getDraftId, getPublishedId, getVersionFromId, getVersionId, isDraftId, isVersionId } from "@sanity/client/csm";
+import { filter, finalize as finalize$1, map as map$1, mergeAll } from "rxjs/operators";
+import { EventSource } from "eventsource";
+import { customAlphabet } from "nanoid";
+import { Readable } from "node:stream";
+import { createNodeFetch } from "get-it/node";
+import { createDebug } from "obug";
+function generateHelpUrl(slug) {
+	return "https://www.sanity.io/help/" + slug;
+}
+const VALID_ASSET_TYPES = ["image", "file"], VALID_INSERT_LOCATIONS = [
+	"before",
+	"after",
+	"replace"
+], dataset = (name) => {
+	if (!/^(~[a-z0-9]{1}[-\w]{0,63}|[a-z0-9]{1}[-\w]{0,63})$/.test(name)) throw Error("Datasets can only contain lowercase characters, numbers, underscores and dashes, and start with tilde, and be maximum 64 characters");
+}, projectId = (id) => {
+	if (!/^[-a-z0-9]+$/i.test(id)) throw Error("`projectId` can only contain only a-z, 0-9 and dashes");
+}, validateAssetType = (type) => {
+	if (VALID_ASSET_TYPES.indexOf(type) === -1) throw Error(`Invalid asset type: ${type}. Must be one of ${VALID_ASSET_TYPES.join(", ")}`);
+}, validateObject = (op, val) => {
+	if (typeof val != "object" || !val || Array.isArray(val)) throw Error(`${op}() takes an object of properties`);
+}, validateDocumentId = (op, id) => {
+	if (typeof id != "string" || !/^[a-z0-9_][a-z0-9_.-]{0,127}$/i.test(id) || id.includes("..")) throw Error(`${op}(): "${id}" is not a valid document ID`);
+}, requireDocumentId = (op, doc) => {
+	if (!doc._id) throw Error(`${op}() requires that the document contains an ID ("_id" property)`);
+	validateDocumentId(op, doc._id);
+}, validateDocumentType = (op, type) => {
+	if (typeof type != "string") throw Error(`\`${op}()\`: \`${type}\` is not a valid document type`);
+}, requireDocumentType = (op, doc) => {
+	if (!doc._type) throw Error(`\`${op}()\` requires that the document contains a type (\`_type\` property)`);
+	validateDocumentType(op, doc._type);
+}, validateVersionIdMatch = (builtVersionId, document) => {
+	if (document._id && document._id !== builtVersionId) throw Error(`The provided document ID (\`${document._id}\`) does not match the generated version ID (\`${builtVersionId}\`)`);
+}, validateInsert = (at, selector, items) => {
+	let signature = "insert(at, selector, items)";
+	if (VALID_INSERT_LOCATIONS.indexOf(at) === -1) {
+		let valid = VALID_INSERT_LOCATIONS.map((loc) => `"${loc}"`).join(", ");
+		throw Error(`${signature} takes an "at"-argument which is one of: ${valid}`);
+	}
+	if (typeof selector != "string") throw Error(`${signature} takes a "selector"-argument which must be a string`);
+	if (!Array.isArray(items)) throw Error(`${signature} takes an "items"-argument which must be an array`);
+}, hasDataset = (config) => {
+	if (config.dataset) return config.dataset;
+	let resource = config.resource;
+	if (resource && resource.type === "dataset") {
+		let segments = resource.id.split(".");
+		if (segments.length !== 2) throw Error("Dataset resource ID must be in the format \"project.dataset\"");
+		return segments[1];
+	}
+	throw Error("`dataset` must be provided to perform queries");
+}, requestTag = (tag) => {
+	if (typeof tag != "string" || !/^[a-z0-9._-]{1,75}$/i.test(tag)) throw Error("Tag can only contain alphanumeric characters, underscores, dashes and dots, and be between one and 75 characters long.");
+	return tag;
+}, resourceConfig = (config) => {
+	let resource = config.resource;
+	if (!resource) throw Error("`resource` must be provided to perform resource queries");
+	let { type, id } = resource;
+	switch (type) {
+		case "dataset":
+			if (id.split(".").length !== 2) throw Error("Dataset resource ID must be in the format \"project.dataset\"");
+			return;
+		case "dashboard":
+		case "media-library":
+		case "canvas": return;
+		default: throw Error(`Unsupported resource type: ${type.toString()}`);
+	}
+}, resourceGuard = (service, config) => {
+	if (config.resource) throw Error(`\`${service}\` does not support resource-based operations`);
+}, EXPERIMENTAL_API_WARNING = "This is an experimental API version";
+function once(fn) {
+	let didCall = !1, returnValue;
+	return (...args) => didCall ? returnValue : (returnValue = fn(...args), didCall = !0, returnValue);
+}
+const createWarningPrinter = (message) => once((...args) => console.warn(message.join(" "), ...args)), printCdnAndWithCredentialsWarning = createWarningPrinter(["Because you set `withCredentials` to true, we will override your `useCdn`", "setting to be false since (cookie-based) credentials are never set on the CDN"]), printCdnWarning = createWarningPrinter([
+	"Since you haven't set a value for `useCdn`, we will deliver content using our",
+	"global, edge-cached API-CDN. If you wish to have content delivered faster, set",
+	"`useCdn: false` to use the Live API. Note: You may incur higher costs using the live API."
+]), printCdnPreviewDraftsWarning = createWarningPrinter(["The Sanity client is configured with the `perspective` set to `drafts` or `previewDrafts`, which doesn't support the API-CDN.", "The Live API will be used instead. Set `useCdn: false` in your configuration to hide this warning."]), printPreviewDraftsDeprecationWarning = createWarningPrinter(["The `previewDrafts` perspective has been renamed to  `drafts` and will be removed in a future API version"]), printBrowserTokenWarning = createWarningPrinter(["You have configured Sanity client to use a token in the browser. This may cause unintentional security issues.", `See ${generateHelpUrl("js-client-browser-token")} for more information and how to hide this warning.`]), printCredentialedTokenWarning = createWarningPrinter(["You have configured Sanity client to use a token, but also provided `withCredentials: true`.", "This is no longer supported - only token will be used - remove `withCredentials: true`."]), printNoApiVersionSpecifiedWarning = createWarningPrinter(["Using the Sanity client without specifying an API version is deprecated.", `See ${generateHelpUrl("js-client-api-version")}`]), printNoDefaultExport = createWarningPrinter(["The default export of @sanity/client has been deprecated. Use the named export `createClient` instead."]), printCreateVersionWithBaseIdWarning = createWarningPrinter(["You have called `createVersion()` with a defined `document`.", "If you are creating a version of a document that already exists, prefer providing `baseId` and `releaseId` instead."]), printDeprecatedUriOptionWarning = createWarningPrinter(["The `uri` request option has been renamed to `url`.", "Please update your code to use `url` instead. Support for `uri` will be removed in a future version."]), printDeprecatedResourceConfigWarning = createWarningPrinter(["The `~experimental_resource` configuration property has been renamed to `resource`.", "Please update your client configuration to use `resource` instead. Support for `~experimental_resource` will be removed in a future version."]), defaultConfig = {
+	apiHost: "https://api.sanity.io",
+	apiVersion: "1",
+	useProjectHostname: !0,
+	stega: { enabled: !1 }
+}, LOCALHOSTS = [
+	"localhost",
+	"127.0.0.1",
+	"0.0.0.0"
+], isLocal = (host) => LOCALHOSTS.indexOf(host) !== -1;
+function validateApiVersion(apiVersion) {
+	if (apiVersion === "1" || apiVersion === "X") return;
+	let apiDate = new Date(apiVersion);
+	if (!(/^\d{4}-\d{2}-\d{2}$/.test(apiVersion) && apiDate instanceof Date && apiDate.getTime() > 0)) throw Error("Invalid API version string, expected `1` or date in format `YYYY-MM-DD`");
+}
+/**
+* @internal - it may have breaking changes in any release
+*/
+function validateApiPerspective(perspective) {
+	if (Array.isArray(perspective) && perspective.length > 1 && perspective.includes("raw")) throw TypeError("Invalid API perspective value: \"raw\". The raw-perspective can not be combined with other perspectives");
+}
+const initConfig = (config, prevConfig) => {
+	let specifiedConfig = {
+		...prevConfig,
+		...config,
+		stega: {
+			...typeof prevConfig.stega == "boolean" ? { enabled: prevConfig.stega } : prevConfig.stega || defaultConfig.stega,
+			...typeof config.stega == "boolean" ? { enabled: config.stega } : config.stega || {}
+		}
+	};
+	specifiedConfig.apiVersion || printNoApiVersionSpecifiedWarning();
+	let newConfig = {
+		...defaultConfig,
+		...specifiedConfig
+	};
+	newConfig["~experimental_resource"] && !newConfig.resource && (printDeprecatedResourceConfigWarning(), newConfig.resource = newConfig["~experimental_resource"]);
+	let resourceConfig$1 = newConfig.resource, projectBased = newConfig.useProjectHostname && !resourceConfig$1;
+	if (typeof Promise > "u") {
+		let helpUrl = generateHelpUrl("js-client-promise-polyfill");
+		throw Error(`No native Promise-implementation found, polyfill needed - see ${helpUrl}`);
+	}
+	if (projectBased && !newConfig.projectId) throw Error("Configuration must contain `projectId`");
+	if (resourceConfig$1 && resourceConfig(newConfig), newConfig.perspective !== void 0 && validateApiPerspective(newConfig.perspective), "encodeSourceMap" in newConfig) throw Error("It looks like you're using options meant for '@sanity/preview-kit/client'. 'encodeSourceMap' is not supported in '@sanity/client'. Did you mean 'stega.enabled'?");
+	if ("encodeSourceMapAtPath" in newConfig) throw Error("It looks like you're using options meant for '@sanity/preview-kit/client'. 'encodeSourceMapAtPath' is not supported in '@sanity/client'. Did you mean 'stega.filter'?");
+	if (typeof newConfig.stega.enabled != "boolean") throw Error(`stega.enabled must be a boolean, received ${newConfig.stega.enabled}`);
+	if (newConfig.stega.enabled && newConfig.stega.studioUrl === void 0) throw Error("stega.studioUrl must be defined when stega.enabled is true");
+	if (newConfig.stega.enabled && typeof newConfig.stega.studioUrl != "string" && typeof newConfig.stega.studioUrl != "function") throw Error(`stega.studioUrl must be a string or a function, received ${newConfig.stega.studioUrl}`);
+	let isBrowser = typeof window < "u" && window.location && window.location.hostname, isLocalhost = isBrowser && isLocal(window.location.hostname), hasToken = !!newConfig.token;
+	newConfig.withCredentials && hasToken && (printCredentialedTokenWarning(), newConfig.withCredentials = !1), isBrowser && isLocalhost && hasToken && newConfig.ignoreBrowserTokenWarning !== !0 ? printBrowserTokenWarning() : newConfig.useCdn === void 0 && printCdnWarning(), projectBased && projectId(newConfig.projectId), newConfig.dataset && dataset(newConfig.dataset), "requestTagPrefix" in newConfig && (newConfig.requestTagPrefix = newConfig.requestTagPrefix ? requestTag(newConfig.requestTagPrefix).replace(/\.+$/, "") : void 0), newConfig.apiVersion = `${newConfig.apiVersion}`.replace(/^v/, ""), newConfig.isDefaultApi = newConfig.apiHost === defaultConfig.apiHost, newConfig.useCdn === !0 && newConfig.withCredentials && printCdnAndWithCredentialsWarning(), newConfig.useCdn = newConfig.useCdn !== !1 && !newConfig.withCredentials, validateApiVersion(newConfig.apiVersion);
+	let hostParts = newConfig.apiHost.split("://", 2), protocol = hostParts[0], host = hostParts[1], cdnHost = newConfig.isDefaultApi ? "apicdn.sanity.io" : host;
+	return projectBased ? (newConfig.url = `${protocol}://${newConfig.projectId}.${host}/v${newConfig.apiVersion}`, newConfig.cdnUrl = `${protocol}://${newConfig.projectId}.${cdnHost}/v${newConfig.apiVersion}`) : (newConfig.url = `${newConfig.apiHost}/v${newConfig.apiVersion}`, newConfig.cdnUrl = newConfig.url), newConfig;
+};
+/**
+* Thrown when the EventSource connection could not be established, or was rejected by the server.
+* Transient failures (network drops, 5xx, 408, 429) are reconnected internally and emitted as
+* `reconnect` events; a permanent rejection (any other 4xx, eg an expired token) errors the
+* stream with this class so consumers can react — check `status` for the rejection code.
+*
+* @public
+*/
+var ConnectionFailedError = class extends Error {
+	name = "ConnectionFailedError";
+	/**
+	* HTTP status code of the rejected connection attempt, if known.
+	* Only set when the EventSource implementation exposes it — the `eventsource`
+	* package used by the client does (as `code` on its error events), while
+	* native EventSource implementations (browser and Node.js) do not.
+	*/
+	status;
+	constructor(message, options = {}) {
+		let { status, ...errorOptions } = options;
+		super(message, errorOptions), this.status = status;
+	}
+}, DisconnectError = class extends Error {
+	name = "DisconnectError";
+	reason;
+	constructor(message, reason, options = {}) {
+		super(message, options), this.reason = reason;
+	}
+}, ChannelError = class extends Error {
+	name = "ChannelError";
+	data;
+	constructor(message, data) {
+		super(message), this.data = data;
+	}
+}, MessageError = class extends Error {
+	name = "MessageError";
+	data;
+	constructor(message, data, options = {}) {
+		super(message, options), this.data = data;
+	}
+}, MessageParseError = class extends Error {
+	name = "MessageParseError";
+};
+const REQUIRED_EVENTS = ["channelError", "disconnect"];
+/**
+* Sanity API specific EventSource handler shared between the listen and live APIs
+*
+* Since the `EventSource` API is not provided by all environments, this function enables custom initialization of the EventSource instance
+* for runtimes that requires polyfilling or custom setup logic (e.g. custom HTTP headers)
+* via the passed `initEventSource` function which must return an EventSource instance.
+*
+* Possible errors to be thrown on the returned observable are:
+* - {@link MessageError}
+* - {@link MessageParseError}
+* - {@link ChannelError}
+* - {@link DisconnectError}
+* - {@link ConnectionFailedError}
+*
+* @param initEventSource - A function that returns an EventSource instance or an Observable that resolves to an EventSource instance
+* @param events - an array of named events from the API to listen for.
+*
+* @internal
+*/
+function connectEventSource(initEventSource, events) {
+	return defer(() => {
+		let es = initEventSource();
+		return isObservable(es) ? es : of(es);
+	}).pipe(mergeMap((es) => connectWithESInstance(es, events)));
+}
+/**
+* Provides an observable from the passed EventSource instance, subscribing to the passed list of names of events types to listen for
+* Handles connection logic, adding/removing event listeners, payload parsing, error propagation, etc.
+*
+* @param es - The EventSource instance
+* @param events - List of event names to listen for
+*/
+function connectWithESInstance(es, events) {
+	return new Observable((observer) => {
+		let requestedEvents = new Set(events), isRequestedEvent = (type) => requestedEvents.has(type), emitOpen = isRequestedEvent("open");
+		function onError(evt) {
+			if ("data" in evt) {
+				let [parseError, event] = parseEvent(evt);
+				observer.error(parseError || !event ? new MessageParseError("Unable to parse EventSource error message", { cause: parseError }) : new MessageError(isRecord(event.data) && typeof event.data.message == "string" ? event.data.message : "", event));
+				return;
+			}
+			if (evt.code !== void 0) {
+				observer.error(new ConnectionFailedError("EventSource connection failed", { status: evt.code }));
+				return;
+			}
+			if (es.readyState === es.CLOSED) observer.error(new ConnectionFailedError("EventSource connection failed"));
+			else {
+				let type = "reconnect";
+				isRequestedEvent(type) && observer.next({ type });
+			}
+		}
+		function onOpen() {
+			let type = "open";
+			isRequestedEvent(type) && observer.next({ type });
+		}
+		function onMessage(message) {
+			let [parseError, event] = parseEvent(message);
+			if (parseError || !event) {
+				observer.error(new MessageParseError("Unable to parse EventSource message", { cause: parseError }));
+				return;
+			}
+			if (message.type === "channelError") {
+				let tag = new URL(es.url).searchParams.get("tag");
+				observer.error(new ChannelError(extractErrorMessage(event?.data, tag), event.data));
+				return;
+			}
+			if (message.type === "disconnect") {
+				observer.error(new DisconnectError(`Server disconnected client: ${isRecord(event.data) && typeof event.data.reason == "string" && event.data.reason || "unknown error"}`));
+				return;
+			}
+			isRequestedEvent(message.type) && observer.next({
+				type: message.type,
+				id: message.lastEventId,
+				...event.data ? { data: event.data } : {}
+			});
+		}
+		es.addEventListener("error", onError), emitOpen && es.addEventListener("open", onOpen);
+		let cleanedEvents = [.../* @__PURE__ */ new Set([...REQUIRED_EVENTS, ...events])].filter((type) => type !== "error" && type !== "open" && type !== "reconnect");
+		return cleanedEvents.forEach((type) => es.addEventListener(type, onMessage)), () => {
+			es.removeEventListener("error", onError), emitOpen && es.removeEventListener("open", onOpen), cleanedEvents.forEach((type) => es.removeEventListener(type, onMessage)), es.close();
+		};
+	});
+}
+function parseEvent(message) {
+	try {
+		let data = typeof message.data == "string" && JSON.parse(message.data);
+		return [null, {
+			type: message.type,
+			id: message.lastEventId,
+			...isEmptyObject(data) ? {} : { data }
+		}];
+	} catch (err) {
+		return [err, null];
+	}
+}
+function extractErrorMessage(err, tag) {
+	let error = isRecord(err) ? err.error : void 0;
+	if (!error) {
+		let message = isRecord(err) ? err.message : void 0;
+		return typeof message == "string" && message || "Unknown listener error";
+	}
+	if (isRecord(error)) {
+		if (isQueryParseError(error)) return formatQueryParseError(error, tag);
+		if (typeof error.description == "string") return error.description;
+	}
+	return typeof error == "string" ? error : JSON.stringify(error, null, 2);
+}
+function isEmptyObject(data) {
+	for (let _ in data) return !1;
+	return !0;
+}
+function getSelection(sel) {
+	if (typeof sel == "string") return { id: sel };
+	if (Array.isArray(sel)) return {
+		query: "*[_id in $ids]",
+		params: { ids: sel }
+	};
+	if (typeof sel == "object" && sel && "query" in sel && typeof sel.query == "string") return "params" in sel && typeof sel.params == "object" && sel.params !== null ? {
+		query: sel.query,
+		params: sel.params
+	} : { query: sel.query };
+	let selectionOpts = [
+		"* Document ID (<docId>)",
+		"* Array of document IDs",
+		"* Object containing `query`"
+	].join("\n");
+	throw Error(`Unknown selection - must be one of:\n\n${selectionOpts}`);
+}
+/** @internal */
+var BasePatch = class {
+	selection;
+	operations;
+	constructor(selection, operations = {}) {
+		this.selection = selection, this.operations = operations;
+	}
+	/**
+	* Sets the given attributes to the document. Does NOT merge objects.
+	* The operation is added to the current patch, ready to be commited by `commit()`
+	*
+	* @param attrs - Attributes to set. To set a deep attribute, use JSONMatch, eg: \{"nested.prop": "value"\}
+	*/
+	set(attrs) {
+		return this._assign("set", attrs);
+	}
+	/**
+	* Sets the given attributes to the document if they are not currently set. Does NOT merge objects.
+	* The operation is added to the current patch, ready to be commited by `commit()`
+	*
+	* @param attrs - Attributes to set. To set a deep attribute, use JSONMatch, eg: \{"nested.prop": "value"\}
+	*/
+	setIfMissing(attrs) {
+		return this._assign("setIfMissing", attrs);
+	}
+	/**
+	* Performs a "diff-match-patch" operation on the string attributes provided.
+	* The operation is added to the current patch, ready to be commited by `commit()`
+	*
+	* @param attrs - Attributes to perform operation on. To set a deep attribute, use JSONMatch, eg: \{"nested.prop": "dmp"\}
+	*/
+	diffMatchPatch(attrs) {
+		return validateObject("diffMatchPatch", attrs), this._assign("diffMatchPatch", attrs);
+	}
+	/**
+	* Unsets the attribute paths provided.
+	* The operation is added to the current patch, ready to be commited by `commit()`
+	*
+	* @param attrs - Attribute paths to unset.
+	*/
+	unset(attrs) {
+		if (!Array.isArray(attrs)) throw Error("unset(attrs) takes an array of attributes to unset, non-array given");
+		return this.operations = Object.assign({}, this.operations, { unset: attrs }), this;
+	}
+	/**
+	* Increment a numeric value. Each entry in the argument is either an attribute or a JSON path. The value may be a positive or negative integer or floating-point value. The operation will fail if target value is not a numeric value, or doesn't exist.
+	*
+	* @param attrs - Object of attribute paths to increment, values representing the number to increment by.
+	*/
+	inc(attrs) {
+		return this._assign("inc", attrs);
+	}
+	/**
+	* Decrement a numeric value. Each entry in the argument is either an attribute or a JSON path. The value may be a positive or negative integer or floating-point value. The operation will fail if target value is not a numeric value, or doesn't exist.
+	*
+	* @param attrs - Object of attribute paths to decrement, values representing the number to decrement by.
+	*/
+	dec(attrs) {
+		return this._assign("dec", attrs);
+	}
+	/**
+	* Provides methods for modifying arrays, by inserting, appending and replacing elements via a JSONPath expression.
+	*
+	* @param at - Location to insert at, relative to the given selector, or 'replace' the matched path
+	* @param selector - JSONPath expression, eg `comments[-1]` or `blocks[_key=="abc123"]`
+	* @param items - Array of items to insert/replace
+	*/
+	insert(at, selector, items) {
+		return validateInsert(at, selector, items), this._assign("insert", {
+			[at]: selector,
+			items
+		});
+	}
+	/**
+	* Append the given items to the array at the given JSONPath
+	*
+	* @param selector - Attribute/path to append to, eg `comments` or `person.hobbies`
+	* @param items - Array of items to append to the array
+	*/
+	append(selector, items) {
+		return this.insert("after", `${selector}[-1]`, items);
+	}
+	/**
+	* Prepend the given items to the array at the given JSONPath
+	*
+	* @param selector - Attribute/path to prepend to, eg `comments` or `person.hobbies`
+	* @param items - Array of items to prepend to the array
+	*/
+	prepend(selector, items) {
+		return this.insert("before", `${selector}[0]`, items);
+	}
+	/**
+	* Change the contents of an array by removing existing elements and/or adding new elements.
+	*
+	* @param selector - Attribute or JSONPath expression for array
+	* @param start - Index at which to start changing the array (with origin 0). If greater than the length of the array, actual starting index will be set to the length of the array. If negative, will begin that many elements from the end of the array (with origin -1) and will be set to 0 if absolute value is greater than the length of the array.x
+	* @param deleteCount - An integer indicating the number of old array elements to remove.
+	* @param items - The elements to add to the array, beginning at the start index. If you don't specify any elements, splice() will only remove elements from the array.
+	*/
+	splice(selector, start, deleteCount, items) {
+		let delAll = deleteCount === void 0 || deleteCount === -1, startIndex = start < 0 ? start - 1 : start, delCount = delAll ? -1 : Math.max(0, start + deleteCount), rangeSelector = `${selector}[${startIndex}:${startIndex < 0 && delCount >= 0 ? "" : delCount}]`;
+		return this.insert("replace", rangeSelector, items || []);
+	}
+	/**
+	* Adds a revision clause, preventing the document from being patched if the `_rev` property does not match the given value
+	*
+	* @param rev - Revision to lock the patch to
+	*/
+	ifRevisionId(rev) {
+		return this.operations.ifRevisionID = rev, this;
+	}
+	/**
+	* Return a plain JSON representation of the patch
+	*/
+	serialize() {
+		return {
+			...getSelection(this.selection),
+			...this.operations
+		};
+	}
+	/**
+	* Return a plain JSON representation of the patch
+	*/
+	toJSON() {
+		return this.serialize();
+	}
+	/**
+	* Clears the patch of all operations
+	*/
+	reset() {
+		return this.operations = {}, this;
+	}
+	_assign(op, props, merge = !0) {
+		return validateObject(op, props), this.operations = Object.assign({}, this.operations, { [op]: Object.assign({}, merge && this.operations[op] || {}, props) }), this;
+	}
+	_set(op, props) {
+		return this._assign(op, props, !1);
+	}
+}, ObservablePatch = class ObservablePatch extends BasePatch {
+	#client;
+	constructor(selection, operations, client) {
+		super(selection, operations), this.#client = client;
+	}
+	/**
+	* Clones the patch
+	*/
+	clone() {
+		return new ObservablePatch(this.selection, { ...this.operations }, this.#client);
+	}
+	commit(options) {
+		if (!this.#client) throw Error("No `client` passed to patch, either provide one or pass the patch to a clients `mutate()` method");
+		let returnFirst = typeof this.selection == "string", opts = Object.assign({
+			returnFirst,
+			returnDocuments: !0
+		}, options);
+		return this.#client.mutate({ patch: this.serialize() }, opts);
+	}
+}, Patch = class Patch extends BasePatch {
+	#client;
+	constructor(selection, operations, client) {
+		super(selection, operations), this.#client = client;
+	}
+	/**
+	* Clones the patch
+	*/
+	clone() {
+		return new Patch(this.selection, { ...this.operations }, this.#client);
+	}
+	commit(options) {
+		if (!this.#client) throw Error("No `client` passed to patch, either provide one or pass the patch to a clients `mutate()` method");
+		let returnFirst = typeof this.selection == "string", opts = Object.assign({
+			returnFirst,
+			returnDocuments: !0
+		}, options);
+		return this.#client.mutate({ patch: this.serialize() }, opts);
+	}
+};
+const defaultMutateOptions = { returnDocuments: !1 };
+/** @internal */
+var BaseTransaction = class {
+	operations;
+	trxId;
+	constructor(operations = [], transactionId) {
+		this.operations = operations, this.trxId = transactionId;
+	}
+	/**
+	* Creates a new Sanity document. If `_id` is provided and already exists, the mutation will fail. If no `_id` is given, one will automatically be generated by the database.
+	* The operation is added to the current transaction, ready to be commited by `commit()`
+	*
+	* @param doc - Document to create. Requires a `_type` property.
+	*/
+	create(doc) {
+		return validateObject("create", doc), this._add({ create: doc });
+	}
+	/**
+	* Creates a new Sanity document. If a document with the same `_id` already exists, the create operation will be ignored.
+	* The operation is added to the current transaction, ready to be commited by `commit()`
+	*
+	* @param doc - Document to create if it does not already exist. Requires `_id` and `_type` properties.
+	*/
+	createIfNotExists(doc) {
+		let op = "createIfNotExists";
+		return validateObject(op, doc), requireDocumentId(op, doc), this._add({ [op]: doc });
+	}
+	/**
+	* Creates a new Sanity document, or replaces an existing one if the same `_id` is already used.
+	* The operation is added to the current transaction, ready to be commited by `commit()`
+	*
+	* @param doc - Document to create or replace. Requires `_id` and `_type` properties.
+	*/
+	createOrReplace(doc) {
+		let op = "createOrReplace";
+		return validateObject(op, doc), requireDocumentId(op, doc), this._add({ [op]: doc });
+	}
+	/**
+	* Deletes the document with the given document ID
+	* The operation is added to the current transaction, ready to be commited by `commit()`
+	*
+	* @param documentId - Document ID to delete
+	*/
+	delete(documentId) {
+		return validateDocumentId("delete", documentId), this._add({ delete: { id: documentId } });
+	}
+	transactionId(id) {
+		return id ? (this.trxId = id, this) : this.trxId;
+	}
+	/**
+	* Return a plain JSON representation of the transaction
+	*/
+	serialize() {
+		return [...this.operations];
+	}
+	/**
+	* Return a plain JSON representation of the transaction
+	*/
+	toJSON() {
+		return this.serialize();
+	}
+	/**
+	* Clears the transaction of all operations
+	*/
+	reset() {
+		return this.operations = [], this;
+	}
+	_add(mut) {
+		return this.operations.push(mut), this;
+	}
+}, Transaction = class Transaction extends BaseTransaction {
+	#client;
+	constructor(operations, client, transactionId) {
+		super(operations, transactionId), this.#client = client;
+	}
+	/**
+	* Clones the transaction
+	*/
+	clone() {
+		return new Transaction([...this.operations], this.#client, this.trxId);
+	}
+	commit(options) {
+		if (!this.#client) throw Error("No `client` passed to transaction, either provide one or pass the transaction to a clients `mutate()` method");
+		return this.#client.mutate(this.serialize(), Object.assign({ transactionId: this.trxId }, defaultMutateOptions, options || {}));
+	}
+	patch(patchOrDocumentId, patchOps) {
+		let isBuilder = typeof patchOps == "function", isPatch = typeof patchOrDocumentId != "string" && patchOrDocumentId instanceof Patch, isMutationSelection = typeof patchOrDocumentId == "object" && ("query" in patchOrDocumentId || "id" in patchOrDocumentId);
+		if (isPatch) return this._add({ patch: patchOrDocumentId.serialize() });
+		if (isBuilder) {
+			let patch = patchOps(new Patch(patchOrDocumentId, {}, this.#client));
+			if (!(patch instanceof Patch)) throw Error("function passed to `patch()` must return the patch");
+			return this._add({ patch: patch.serialize() });
+		}
+		if (isMutationSelection) {
+			let patch = new Patch(patchOrDocumentId, patchOps || {}, this.#client);
+			return this._add({ patch: patch.serialize() });
+		}
+		return this._add({ patch: {
+			id: patchOrDocumentId,
+			...patchOps
+		} });
+	}
+}, ObservableTransaction = class ObservableTransaction extends BaseTransaction {
+	#client;
+	constructor(operations, client, transactionId) {
+		super(operations, transactionId), this.#client = client;
+	}
+	/**
+	* Clones the transaction
+	*/
+	clone() {
+		return new ObservableTransaction([...this.operations], this.#client, this.trxId);
+	}
+	commit(options) {
+		if (!this.#client) throw Error("No `client` passed to transaction, either provide one or pass the transaction to a clients `mutate()` method");
+		return this.#client.mutate(this.serialize(), Object.assign({ transactionId: this.trxId }, defaultMutateOptions, options || {}));
+	}
+	patch(patchOrDocumentId, patchOps) {
+		let isBuilder = typeof patchOps == "function";
+		if (typeof patchOrDocumentId != "string" && patchOrDocumentId instanceof ObservablePatch) return this._add({ patch: patchOrDocumentId.serialize() });
+		if (isBuilder) {
+			let patch = patchOps(new ObservablePatch(patchOrDocumentId, {}, this.#client));
+			if (!(patch instanceof ObservablePatch)) throw Error("function passed to `patch()` must return the patch");
+			return this._add({ patch: patch.serialize() });
+		}
+		return this._add({ patch: {
+			id: patchOrDocumentId,
+			...patchOps
+		} });
+	}
+};
+/**
+* Project the public request options (`timeout: 0` to disable,
+* `withCredentials`, `maxRedirects`, the function/object-form `fetch`, ...)
+* plus the client config into a get-it v9 fetch-shaped request. This is the
+* single translation boundary between the client's public option names and
+* the transport — everything below it speaks get-it v9.
+*
+* Reads the live client config, so reconfiguration via `client.config()` /
+* `withConfig()` (token, headers, proxy, ...) applies to subsequent requests.
+*
+* @internal
+*/
+function requestOptions(config, overrides = {}) {
+	let headers = {};
+	config.headers && Object.assign(headers, config.headers);
+	let token = overrides.token || config.token;
+	token && (headers.Authorization = `Bearer ${token}`), !overrides.useGlobalApi && !config.useProjectHostname && config.projectId && (headers["X-Sanity-Project-ID"] = config.projectId);
+	let request = {
+		url: overrides.url,
+		headers: Object.assign(headers, overrides.headers || {})
+	};
+	overrides.method && (request.method = overrides.method), overrides.body !== void 0 && (request.body = overrides.body), overrides.query && (request.query = expandQueryArrays(overrides.query)), overrides.signal && (request.signal = overrides.signal), (overrides.withCredentials === void 0 ? config.withCredentials : overrides.withCredentials) && (request.credentials = "include"), typeof overrides.maxRedirects == "number" && (request.redirect = overrides.maxRedirects === 0 ? "manual" : "follow");
+	let timeout = overrides.timeout === void 0 ? config.timeout : overrides.timeout;
+	request.timeout = timeout === void 0 ? 3e5 : timeout !== 0 && timeout, overrides.useAbortSignal === !1 && !request.signal && (request.timeout = typeof request.timeout == "number" && request.timeout > 0 && {
+		total: request.timeout,
+		signal: !1
+	});
+	let fetchOption = typeof overrides.fetch == "object" && typeof config.fetch == "object" ? {
+		...config.fetch,
+		...overrides.fetch
+	} : overrides.fetch || config.fetch;
+	return typeof fetchOption == "function" ? request.fetch = fetchOption : typeof fetchOption == "object" && fetchOption && (request.meta = {
+		...request.meta,
+		fetchInit: fetchOption
+	}), !request.fetch && config.resolveFetch && (request.fetch = config.resolveFetch(typeof config.proxy == "string" ? config.proxy : void 0)), typeof overrides.maxRetries == "number" && (request.maxRetries = overrides.maxRetries), typeof config.lineage == "string" && config.lineage && (request.meta = {
+		...request.meta,
+		lineage: config.lineage
+	}), request;
+}
+/**
+* Expand array-valued query params into repeated keys.
+*
+* get-it v9 stringifies a plain object's values directly, so passing
+* `{meta: ['palette', 'location']}` would produce `?meta=palette,location`
+* — which Content Lake doesn't recognise. Repeated keys
+* (`?meta=palette&meta=location`) are produced via `URLSearchParams`.
+*/
+function expandQueryArrays(query) {
+	if (query instanceof URLSearchParams || !query || typeof query != "object" || !Object.values(query).some(Array.isArray)) return query;
+	let params = new URLSearchParams();
+	for (let [key, value] of Object.entries(query)) if (value != null) {
+		if (Array.isArray(value)) for (let item of value) item != null && params.append(key, `${item}`);
+		else params.append(key, `${value}`);
+	}
+	return params;
+}
+var import_dist = require_dist();
+/**
+* Can take a `result` JSON from a `const {result} = client.fetch(query, params, {filterResponse: false})`
+* and remove all stega-encoded data from it.
+* If the result type has strings branded as `StegaString` (by `ClientReturnStega` or `stegaBrand()`),
+* the brand is stripped and the original string type is restored.
+* @public
+*/
+function stegaClean(result) {
+	return (0, import_dist.vercelStegaClean)(result);
+}
+const encodeQueryString = ({ query, params = {}, options = {} }) => {
+	let searchParams = new URLSearchParams(), { tag, includeMutations, returnQuery, ...opts } = options;
+	tag && searchParams.append("tag", tag), searchParams.append("query", query);
+	for (let [key, value] of Object.entries(params)) value !== void 0 && searchParams.append(`$${key}`, JSON.stringify(value));
+	for (let [key, value] of Object.entries(opts)) value && searchParams.append(key, `${value}`);
+	return returnQuery === !1 && searchParams.append("returnQuery", "false"), includeMutations === !1 && searchParams.append("includeMutations", "false"), `?${searchParams}`;
+}, excludeFalsey = (param, defValue) => param === !1 ? void 0 : param === void 0 ? defValue : param, getMutationQuery = (options = {}) => ({
+	dryRun: options.dryRun,
+	returnIds: !0,
+	returnDocuments: excludeFalsey(options.returnDocuments, !0),
+	visibility: options.visibility || "sync",
+	autoGenerateArrayKeys: options.autoGenerateArrayKeys,
+	skipCrossDatasetReferenceValidation: options.skipCrossDatasetReferenceValidation
+}), indexBy = (docs, attr) => docs.reduce((indexed, doc) => (indexed[attr(doc)] = doc, indexed), Object.create(null));
+/**
+* Resolve the effective stega config, cleaned params, response mapper and
+* transport request options for a `fetch()` call. Shared by the observable and
+* promise paths.
+*
+* @internal
+*/
+function _fetchRequest(_stega, _params, options) {
+	let stega = "stega" in options ? {
+		..._stega,
+		...typeof options.stega == "boolean" ? { enabled: options.stega } : options.stega || {}
+	} : _stega, params = stega.enabled ? stegaClean(_params) : _params, mapResponse = options.filterResponse === !1 ? (res) => res : (res) => res.result, { cache, next, ...opts } = {
+		useAbortSignal: options.signal !== void 0,
+		resultSourceMap: stega.enabled ? "withKeyArraySelector" : options.resultSourceMap,
+		...options,
+		returnQuery: options.filterResponse === !1 && options.returnQuery !== !1
+	};
+	return {
+		stega,
+		params,
+		mapResponse,
+		reqOpts: cache !== void 0 || next !== void 0 ? {
+			...opts,
+			fetch: {
+				cache,
+				next
+			}
+		} : opts
+	};
+}
+/** @internal */
+function _fetchObservable(client, httpRequest, _stega, query, _params = {}, options = {}) {
+	return _observe(options.signal, (signal) => _fetch(client, httpRequest, _stega, query, _params, {
+		...options,
+		signal
+	}));
+}
+/**
+* Promise-based sibling of {@link _fetchObservable}.
+*
+* @internal
+*/
+function _fetch(client, httpRequest, _stega, query, _params = {}, options = {}) {
+	let { stega, params, mapResponse, reqOpts } = _fetchRequest(_stega, _params, options), request = _dataRequest(client, httpRequest, "query", {
+		query,
+		params
+	}, reqOpts);
+	return stega.enabled ? Promise.all([request, import("./stegaEncodeSourceMap-DbM2fTN4.js")]).then(([res, { stegaEncodeSourceMap }]) => {
+		let result = stegaEncodeSourceMap(res.result, res.resultSourceMap, stega);
+		return mapResponse({
+			...res,
+			result
+		});
+	}) : request.then(mapResponse);
+}
+/** @internal */
+function _getDocumentObservable(client, httpRequest, id, opts = {}) {
+	return _observe(opts.signal, (signal) => _request(client, httpRequest, _getDocumentOptions(client, id, {
+		...opts,
+		signal
+	})).then((body) => _mapGetDocument(body, opts.includeAllVersions)));
+}
+/** @internal */
+function _getDocument(client, httpRequest, id, opts = {}) {
+	return _request(client, httpRequest, _getDocumentOptions(client, id, opts)).then((body) => _mapGetDocument(body, opts.includeAllVersions));
+}
+/**
+* Resolve the document id (honoring `releaseId`) and build the transport
+* request options for {@link _getDocumentObservable}. Shared by the observable and
+* promise paths.
+*
+* @internal
+*/
+function _getDocumentOptions(client, id, opts) {
+	let docId = id;
+	if (opts.releaseId) {
+		let versionId = getVersionFromId(id);
+		if (!versionId) {
+			if (isDraftId(id)) throw Error(`The document ID (\`${id}\`) is a draft, but \`options.releaseId\` is set as \`${opts.releaseId}\``);
+			docId = getVersionId(id, opts.releaseId);
+		} else if (versionId !== opts.releaseId) throw Error(`The document ID (\`${id}\`) is already a version of \`${versionId}\` release, but this does not match the provided \`options.releaseId\` (\`${opts.releaseId}\`)`);
+	}
+	return {
+		url: _getDataUrl(client, "doc", docId),
+		tag: opts.tag,
+		signal: opts.signal,
+		query: opts.includeAllVersions === void 0 ? void 0 : { includeAllVersions: opts.includeAllVersions }
+	};
+}
+function _mapGetDocument(body, includeAllVersions) {
+	let documents = body.documents;
+	return documents ? includeAllVersions ? documents : documents[0] : includeAllVersions ? [] : void 0;
+}
+/** @internal */
+function _getDocumentsObservable(client, httpRequest, ids, opts = {}) {
+	return _observe(opts.signal, (signal) => _getDocuments(client, httpRequest, ids, {
+		...opts,
+		signal
+	}));
+}
+/**
+* Promise-based sibling of {@link _getDocumentsObservable}.
+*
+* @internal
+*/
+function _getDocuments(client, httpRequest, ids, opts = {}) {
+	return _request(client, httpRequest, _getDocumentsOptions(client, ids, opts)).then((body) => _mapGetDocuments(body, ids));
+}
+function _getDocumentsOptions(client, ids, opts) {
+	return {
+		url: _getDataUrl(client, "doc", ids.join(",")),
+		tag: opts.tag,
+		signal: opts.signal
+	};
+}
+function _mapGetDocuments(body, ids) {
+	let indexed = indexBy(body.documents || [], (doc) => doc._id);
+	return ids.map((id) => indexed[id] || null);
+}
+/** @internal */
+function _documentsExistsObservable(client, httpRequest, ids, opts = {}) {
+	return _observe(opts.signal, (signal) => _documentsExists(client, httpRequest, ids, {
+		...opts,
+		signal
+	}));
+}
+/**
+* Promise-based sibling of {@link _documentsExistsObservable}. Checks document
+* existence in batches, resolving to the set of IDs that exist.
+*
+* @internal
+*/
+async function _documentsExists(client, httpRequest, ids, opts = {}) {
+	let existing = /* @__PURE__ */ new Set();
+	if (ids.length === 0) return existing;
+	for (let i = 0; i < ids.length; i += 100) {
+		let batchIds = ids.slice(i, i + 100), body = await _request(client, httpRequest, {
+			url: _getDataUrl(client, "doc", batchIds.map(encodeURIComponent).join(",")),
+			tag: opts.tag,
+			signal: opts.signal,
+			query: { excludeContent: !0 }
+		}), missing = /* @__PURE__ */ new Set();
+		for (let omitted of body.omitted || []) omitted.reason === "existence" && missing.add(omitted.id);
+		for (let id of batchIds) missing.has(id) || existing.add(id);
+	}
+	return existing;
+}
+/** @internal */
+function _getReleaseDocumentsObservable(client, httpRequest, releaseId, opts = {}) {
+	return _observe(opts.signal, (signal) => _getReleaseDocuments(client, httpRequest, releaseId, {
+		...opts,
+		signal
+	}));
+}
+/**
+* Promise-based sibling of {@link _getReleaseDocumentsObservable}.
+*
+* @internal
+*/
+function _getReleaseDocuments(client, httpRequest, releaseId, opts = {}) {
+	return _dataRequest(client, httpRequest, "query", {
+		query: "*[sanity::partOfRelease($releaseId)]",
+		params: { releaseId }
+	}, opts);
+}
+/** @internal */
+function _createIfNotExistsObservable(client, httpRequest, doc, options) {
+	return _observe(options?.signal, (signal) => _createIfNotExists(client, httpRequest, doc, {
+		...options,
+		signal
+	}));
+}
+/** @internal */
+function _createOrReplaceObservable(client, httpRequest, doc, options) {
+	return _observe(options?.signal, (signal) => _createOrReplace(client, httpRequest, doc, {
+		...options,
+		signal
+	}));
+}
+/** @internal */
+function _createVersionObservable(client, httpRequest, doc, publishedId, options) {
+	return _observe(options?.signal, (signal) => _createVersion(client, httpRequest, doc, publishedId, {
+		...options,
+		signal
+	}));
+}
+/** @internal */
+function _createVersionFromBaseObservable(client, httpRequest, publishedId, baseId, releaseId, ifBaseRevisionId, options) {
+	return _observe(options?.signal, (signal) => _createVersionFromBase(client, httpRequest, publishedId, baseId, releaseId, ifBaseRevisionId, {
+		...options,
+		signal
+	}));
+}
+/** @internal */
+function _deleteObservable(client, httpRequest, selection, options) {
+	return _observe(options?.signal, (signal) => _delete(client, httpRequest, selection, {
+		...options,
+		signal
+	}));
+}
+/** @internal */
+function _discardVersionObservable(client, httpRequest, versionId, purge = !1, options) {
+	return _observe(options?.signal, (signal) => _discardVersion(client, httpRequest, versionId, purge, {
+		...options,
+		signal
+	}));
+}
+/** @internal */
+function _replaceVersionObservable(client, httpRequest, doc, options) {
+	return _observe(options?.signal, (signal) => _replaceVersion(client, httpRequest, doc, {
+		...options,
+		signal
+	}));
+}
+/** @internal */
+function _unpublishVersionObservable(client, httpRequest, versionId, publishedId, options) {
+	return _observe(options?.signal, (signal) => _unpublishVersion(client, httpRequest, versionId, publishedId, {
+		...options,
+		signal
+	}));
+}
+/** @internal */
+function _mutateObservable(client, httpRequest, mutations, options) {
+	return _observe(options?.signal, (signal) => _mutate(client, httpRequest, mutations, {
+		...options,
+		signal
+	}));
+}
+/**
+* @internal
+*/
+function _actionObservable(client, httpRequest, actions, options) {
+	return _observe(options?.signal, (signal) => _action(client, httpRequest, actions, {
+		...options,
+		signal
+	}));
+}
+/**
+* Build the transport request options for a data endpoint (`query` / `mutate`
+* / `actions`). Shared by the observable and promise request paths.
+*
+* @internal
+*/
+function _dataRequestOptions(client, endpoint, body, options = {}) {
+	let isMutation = endpoint === "mutate", isAction = endpoint === "actions", isQuery = endpoint === "query", strQuery = isMutation || isAction ? "" : encodeQueryString(body), useGet = !isMutation && !isAction && strQuery.length < 11264, stringQuery = useGet ? strQuery : "", returnFirst = options.returnFirst, { timeout, token, tag, headers, returnQuery, lastLiveEventId, cacheMode } = options, url = _getDataUrl(client, endpoint, stringQuery);
+	return {
+		reqOptions: {
+			method: useGet ? "GET" : "POST",
+			url,
+			body: useGet ? void 0 : body,
+			query: isMutation && getMutationQuery(options),
+			timeout,
+			headers,
+			token,
+			tag,
+			returnQuery,
+			perspective: options.perspective,
+			variant: options.variant,
+			resultSourceMap: options.resultSourceMap,
+			lastLiveEventId: Array.isArray(lastLiveEventId) ? lastLiveEventId[0] : lastLiveEventId,
+			cacheMode,
+			canUseCdn: isQuery,
+			signal: options.signal,
+			fetch: options.fetch,
+			useAbortSignal: options.useAbortSignal,
+			useCdn: options.useCdn
+		},
+		isMutation,
+		returnFirst
+	};
+}
+/**
+* Shape the raw response body of a data request. For mutations this reduces
+* the API response to documents or ids; everything else passes through. Pure
+* function shared by the observable and promise request paths.
+*
+* @internal
+*/
+function _mapDataResponse(res, isMutation, returnFirst, returnDocuments) {
+	if (!isMutation) return res;
+	let results = res.results || [];
+	if (returnDocuments) return returnFirst ? results[0] && results[0].document : results.map((mut) => mut.document);
+	let key = returnFirst ? "documentId" : "documentIds", ids = returnFirst ? results[0] && results[0].id : results.map((mut) => mut.id);
+	return {
+		transactionId: res.transactionId,
+		results,
+		[key]: ids
+	};
+}
+/**
+* @internal
+*/
+function _dataRequest(client, httpRequest, endpoint, body, options = {}) {
+	let { reqOptions, isMutation, returnFirst } = _dataRequestOptions(client, endpoint, body, options);
+	return _request(client, httpRequest, reqOptions).then((res) => _mapDataResponse(res, isMutation, returnFirst, options.returnDocuments));
+}
+/**
+* @internal
+*/
+function _createObservable(client, httpRequest, doc, op, options = {}) {
+	return _observe(options.signal, (signal) => _create(client, httpRequest, doc, op, {
+		...options,
+		signal
+	}));
+}
+/**
+* Promise-based sibling of {@link _createObservable}.
+*
+* @internal
+*/
+function _create(client, httpRequest, doc, op, options = {}) {
+	let mutation = { [op]: doc }, opts = Object.assign({
+		returnFirst: !0,
+		returnDocuments: !0
+	}, options);
+	return _dataRequest(client, httpRequest, "mutate", { mutations: [mutation] }, opts);
+}
+/**
+* Promise-based sibling of {@link _actionObservable}.
+*
+* @internal
+*/
+function _action(client, httpRequest, actions, options) {
+	return _dataRequest(client, httpRequest, "actions", {
+		actions: Array.isArray(actions) ? actions : [actions],
+		transactionId: options && options.transactionId || void 0,
+		skipCrossDatasetReferenceValidation: options && options.skipCrossDatasetReferenceValidation || void 0,
+		dryRun: options && options.dryRun || void 0
+	}, options);
+}
+/**
+* Promise-based sibling of {@link _mutateObservable}.
+*
+* @internal
+*/
+function _mutate(client, httpRequest, mutations, options) {
+	let mut;
+	return mut = mutations instanceof Patch || mutations instanceof ObservablePatch ? { patch: mutations.serialize() } : mutations instanceof Transaction || mutations instanceof ObservableTransaction ? mutations.serialize() : mutations, _dataRequest(client, httpRequest, "mutate", {
+		mutations: Array.isArray(mut) ? mut : [mut],
+		transactionId: options && options.transactionId || void 0
+	}, options);
+}
+/**
+* Promise-based sibling of {@link _deleteObservable}.
+*
+* @internal
+*/
+function _delete(client, httpRequest, selection, options) {
+	return _dataRequest(client, httpRequest, "mutate", { mutations: [{ delete: getSelection(selection) }] }, options);
+}
+/**
+* Promise-based sibling of {@link _createIfNotExistsObservable}.
+*
+* @internal
+*/
+function _createIfNotExists(client, httpRequest, doc, options) {
+	return requireDocumentId("createIfNotExists", doc), _create(client, httpRequest, doc, "createIfNotExists", options);
+}
+/**
+* Promise-based sibling of {@link _createOrReplaceObservable}.
+*
+* @internal
+*/
+function _createOrReplace(client, httpRequest, doc, options) {
+	return requireDocumentId("createOrReplace", doc), _create(client, httpRequest, doc, "createOrReplace", options);
+}
+/**
+* Promise-based sibling of {@link _createVersionObservable}.
+*
+* @internal
+*/
+function _createVersion(client, httpRequest, doc, publishedId, options) {
+	return requireDocumentId("createVersion", doc), requireDocumentType("createVersion", doc), printCreateVersionWithBaseIdWarning(), _action(client, httpRequest, {
+		actionType: "sanity.action.document.version.create",
+		publishedId,
+		document: doc
+	}, options);
+}
+/**
+* Promise-based sibling of {@link _createVersionFromBaseObservable}.
+*
+* @internal
+*/
+function _createVersionFromBase(client, httpRequest, publishedId, baseId, releaseId, ifBaseRevisionId, options) {
+	if (!baseId) throw Error("`createVersion()` requires `baseId` when no `document` is provided");
+	if (!publishedId) throw Error("`createVersion()` requires `publishedId` when `baseId` is provided");
+	return validateDocumentId("createVersion", baseId), validateDocumentId("createVersion", publishedId), _action(client, httpRequest, {
+		actionType: "sanity.action.document.version.create",
+		publishedId,
+		baseId,
+		versionId: releaseId ? getVersionId(publishedId, releaseId) : getDraftId(publishedId),
+		ifBaseRevisionId
+	}, options);
+}
+/**
+* Promise-based sibling of {@link _discardVersionObservable}.
+*
+* @internal
+*/
+function _discardVersion(client, httpRequest, versionId, purge = !1, options) {
+	return _action(client, httpRequest, {
+		actionType: "sanity.action.document.version.discard",
+		versionId,
+		purge
+	}, options);
+}
+/**
+* Promise-based sibling of {@link _replaceVersionObservable}.
+*
+* @internal
+*/
+function _replaceVersion(client, httpRequest, doc, options) {
+	return requireDocumentId("replaceVersion", doc), requireDocumentType("replaceVersion", doc), _action(client, httpRequest, {
+		actionType: "sanity.action.document.version.replace",
+		document: doc
+	}, options);
+}
+/**
+* Promise-based sibling of {@link _unpublishVersionObservable}.
+*
+* @internal
+*/
+function _unpublishVersion(client, httpRequest, versionId, publishedId, options) {
+	return _action(client, httpRequest, {
+		actionType: "sanity.action.document.version.unpublish",
+		versionId,
+		publishedId
+	}, options);
+}
+const hasDataConfig = (client) => {
+	let config = client.config();
+	return config.dataset !== void 0 && config.projectId !== void 0 || config.resource !== void 0;
+}, isQuery = (client, uri) => hasDataConfig(client) && uri.startsWith(_getDataUrl(client, "query")), isMutate = (client, uri) => hasDataConfig(client) && uri.startsWith(_getDataUrl(client, "mutate")), isDoc = (client, uri) => hasDataConfig(client) && uri.startsWith(_getDataUrl(client, "doc", "")), isListener = (client, uri) => hasDataConfig(client) && uri.startsWith(_getDataUrl(client, "listen")), isHistory = (client, uri) => hasDataConfig(client) && uri.startsWith(_getDataUrl(client, "history", "")), isData = (client, uri) => uri.startsWith("/data/") || isQuery(client, uri) || isMutate(client, uri) || isDoc(client, uri) || isListener(client, uri) || isHistory(client, uri);
+/**
+* Build the final request options (URL, headers, query params, etc.) used by
+* both the regular request pipeline and the asset upload path.
+*
+* @internal
+*/
+function _prepareRequest(client, options) {
+	options.uri !== void 0 && printDeprecatedUriOptionWarning();
+	let uri = options.uri || options.url;
+	if (typeof uri != "string") throw TypeError("Request options must include a `url`");
+	let config = client.config(), canUseCdn = options.canUseCdn === void 0 ? ["GET", "HEAD"].indexOf(options.method || "GET") >= 0 && isData(client, uri) : options.canUseCdn, useCdn = (options.useCdn ?? config.useCdn) && canUseCdn, tag = options.tag && config.requestTagPrefix ? [config.requestTagPrefix, options.tag].join(".") : options.tag || config.requestTagPrefix;
+	if (tag && options.tag !== null && (options.query = {
+		tag: requestTag(tag),
+		...options.query
+	}), [
+		"GET",
+		"HEAD",
+		"POST"
+	].indexOf(options.method || "GET") >= 0 && isQuery(client, uri)) {
+		let resultSourceMap = options.resultSourceMap ?? config.resultSourceMap;
+		resultSourceMap !== void 0 && resultSourceMap !== !1 && (options.query = {
+			resultSourceMap,
+			...options.query
+		});
+		let perspectiveOption = options.perspective || config.perspective;
+		perspectiveOption !== void 0 && (perspectiveOption === "previewDrafts" && printPreviewDraftsDeprecationWarning(), validateApiPerspective(perspectiveOption), options.query = {
+			perspective: Array.isArray(perspectiveOption) ? perspectiveOption.join(",") : perspectiveOption,
+			...options.query
+		}, (Array.isArray(perspectiveOption) && perspectiveOption.length > 0 || perspectiveOption === "previewDrafts" || perspectiveOption === "drafts") && useCdn && (useCdn = !1, printCdnPreviewDraftsWarning()));
+		let variantOption = options.variant || config.variant;
+		typeof variantOption == "string" && (options.query = {
+			variant: variantOption,
+			...options.query
+		}), typeof variantOption == "object" && (options.query = {
+			variantCondition: variantConditionsToQueryArray(variantOption),
+			...options.query
+		}), options.lastLiveEventId && (options.query = {
+			...options.query,
+			lastLiveEventId: options.lastLiveEventId
+		}), options.returnQuery === !1 && (options.query = {
+			returnQuery: "false",
+			...options.query
+		}), useCdn && options.cacheMode == "noStale" && (options.query = {
+			cacheMode: "noStale",
+			...options.query
+		});
+	}
+	return requestOptions(config, Object.assign({}, options, { url: _getUrl(client, uri, useCdn) }));
+}
+/**
+* Wrap a promise-returning request in a cold, single-value Observable.
+*
+* Each subscription invokes `run` with a fresh `AbortSignal` that is aborted
+* when the subscriber unsubscribes — so unsubscribing cancels the in-flight
+* `fetch`. A caller-supplied `userSignal` is chained in too, so the request
+* still aborts when the caller's own signal fires. The single resolved value
+* (or rejection) is forwarded to the subscriber.
+*
+* This is the bridge that lets the observable client surface reuse the exact
+* same promise implementations as the promise client surface, with no
+* duplicated request logic.
+*
+* @internal
+*/
+function _observe(userSignal, run) {
+	return new Observable((subscriber) => {
+		let controller = new AbortController();
+		return run(userSignal ? AbortSignal.any([userSignal, controller.signal]) : controller.signal).then((value) => {
+			subscriber.next(value), subscriber.complete();
+		}, (err) => subscriber.error(err)), () => controller.abort();
+	});
+}
+/**
+* Promise-based sibling of {@link _requestObservable}. Resolves directly to
+* the parsed response body without ever constructing an Observable. The abort
+* signal is honored by the underlying `fetch` (it is threaded onto the request
+* options), so no RxJS-level teardown is required.
+*
+* @internal
+*/
+function _request(client, httpRequest, options) {
+	return httpRequest(_prepareRequest(client, options), client.config().requestHandler).then((body) => body);
+}
+/**
+* Execute an HTTP request through the regular pipeline and resolve to the
+* parsed response body. Observable wrapper over {@link _request}.
+*
+* @internal
+*/
+function _requestObservable(client, httpRequest, options) {
+	return _observe(options.signal, (signal) => _request(client, httpRequest, {
+		...options,
+		signal
+	}));
+}
+/**
+* Execute an asset upload through the underlying requester directly,
+* exposing the full upload event stream (progress + response).
+*
+* Bypasses the body-only `HttpRequest` boundary so progress events from the
+* transport layer can surface to consumers, reading the resolved requester
+* straight off the initialized config.
+*
+* @internal
+*/
+function _uploadObservable(client, options) {
+	let reqOptions = _prepareRequest(client, options), requester = client.config().requester, request = new Observable((subscriber) => requester(reqOptions).subscribe(subscriber)).pipe(filter((event) => event?.type === "progress" || event?.type === "response"), map$1((event) => event.type === "progress" ? {
+		type: "progress",
+		stage: event.stage,
+		percent: event.percent,
+		total: event.total,
+		loaded: event.loaded,
+		lengthComputable: event.lengthComputable
+	} : {
+		type: "response",
+		body: event.body
+	}));
+	return options.signal ? request.pipe(_withAbortSignal(options.signal)) : request;
+}
+/**
+* @internal
+*/
+function _getDataUrl(client, operation, path) {
+	let config = client.config();
+	if (config.resource) return resourceConfig(config), `${resourceDataBase(config)}/${path === void 0 ? operation : `${operation}/${path}`}`.replace(/\/($|\?)/, "$1");
+	let baseUri = `/${operation}/${hasDataset(config)}`;
+	return `/data${path === void 0 ? baseUri : `${baseUri}/${path}`}`.replace(/\/($|\?)/, "$1");
+}
+/**
+* @internal
+*/
+function _getUrl(client, uri, canUseCdn = !1) {
+	let { url, cdnUrl } = client.config();
+	return `${canUseCdn ? cdnUrl : url}/${uri.replace(/^\//, "")}`;
+}
+/**
+* @internal
+*/
+function _withAbortSignal(signal) {
+	return (input) => new Observable((observer) => {
+		let abort = () => observer.error(_createAbortError(signal));
+		if (signal && signal.aborted) {
+			abort();
+			return;
+		}
+		let subscription = input.subscribe(observer);
+		return signal.addEventListener("abort", abort), () => {
+			signal.removeEventListener("abort", abort), subscription.unsubscribe();
+		};
+	});
+}
+/**
+* `DOMException` is globally available in every supported runtime
+* (Node 22.12+ and all modern browsers), so we can construct one directly.
+*
+* @internal
+*/
+function _createAbortError(signal) {
+	return new DOMException(signal?.reason ?? "The operation was aborted.", "AbortError");
+}
+const resourceDataBase = (config) => {
+	let resource = config.resource;
+	if (!resource) throw Error("`resource` must be provided to perform resource queries");
+	let { type, id } = resource;
+	switch (type) {
+		case "dataset": {
+			let segments = id.split(".");
+			if (segments.length !== 2) throw Error("Dataset ID must be in the format \"project.dataset\"");
+			return `/projects/${segments[0]}/datasets/${segments[1]}`;
+		}
+		case "canvas": return `/canvases/${id}`;
+		case "media-library": return `/media-libraries/${id}`;
+		case "dashboard": return `/dashboards/${id}`;
+		default: throw Error(`Unsupported resource type: ${type.toString()}`);
+	}
+};
+function variantConditionsToQueryArray(variantConditions) {
+	return Object.entries(variantConditions).map(([condition, value]) => `${condition}:${value}`).toSorted();
+}
+function _generateObservable(client, httpRequest, request) {
+	return _requestObservable(client, httpRequest, {
+		method: "POST",
+		url: `/agent/action/generate/${hasDataset(client.config())}`,
+		body: request
+	});
+}
+function _generate(client, httpRequest, request) {
+	return _request(client, httpRequest, {
+		method: "POST",
+		url: `/agent/action/generate/${hasDataset(client.config())}`,
+		body: request
+	});
+}
+function _patch(client, httpRequest, request) {
+	return _request(client, httpRequest, {
+		method: "POST",
+		url: `/agent/action/patch/${hasDataset(client.config())}`,
+		body: request
+	});
+}
+function _prompt(client, httpRequest, request) {
+	return _request(client, httpRequest, {
+		method: "POST",
+		url: `/agent/action/prompt/${hasDataset(client.config())}`,
+		body: request
+	});
+}
+function _transformObservable(client, httpRequest, request) {
+	return _requestObservable(client, httpRequest, {
+		method: "POST",
+		url: `/agent/action/transform/${hasDataset(client.config())}`,
+		body: request
+	});
+}
+function _transform(client, httpRequest, request) {
+	return _request(client, httpRequest, {
+		method: "POST",
+		url: `/agent/action/transform/${hasDataset(client.config())}`,
+		body: request
+	});
+}
+function _translateObservable(client, httpRequest, request) {
+	return _requestObservable(client, httpRequest, {
+		method: "POST",
+		url: `/agent/action/translate/${hasDataset(client.config())}`,
+		body: request
+	});
+}
+function _translate(client, httpRequest, request) {
+	return _request(client, httpRequest, {
+		method: "POST",
+		url: `/agent/action/translate/${hasDataset(client.config())}`,
+		body: request
+	});
+}
+/** @public */
+var ObservableAgentsActionClient = class {
+	#client;
+	#httpRequest;
+	constructor(client, httpRequest) {
+		this.#client = client, this.#httpRequest = httpRequest;
+	}
+	/**
+	* Run an instruction to generate content in a target document.
+	* @param request - instruction request
+	*/
+	generate(request) {
+		return _generateObservable(this.#client, this.#httpRequest, request);
+	}
+	/**
+	* Transform a target document based on a source.
+	* @param request - translation request
+	*/
+	transform(request) {
+		return _transformObservable(this.#client, this.#httpRequest, request);
+	}
+	/**
+	* Translate a target document based on a source.
+	* @param request - translation request
+	*/
+	translate(request) {
+		return _translateObservable(this.#client, this.#httpRequest, request);
+	}
+}, AgentActionsClient = class {
+	#client;
+	#httpRequest;
+	constructor(client, httpRequest) {
+		this.#client = client, this.#httpRequest = httpRequest;
+	}
+	/**
+	* Run an instruction to generate content in a target document.
+	* @param request - instruction request
+	*/
+	generate(request) {
+		return _generate(this.#client, this.#httpRequest, request);
+	}
+	/**
+	* Transform a target document based on a source.
+	* @param request - translation request
+	*/
+	transform(request) {
+		return _transform(this.#client, this.#httpRequest, request);
+	}
+	/**
+	* Translate a target document based on a source.
+	* @param request - translation request
+	*/
+	translate(request) {
+		return _translate(this.#client, this.#httpRequest, request);
+	}
+	/**
+	* Run a raw instruction and return the result either as text or json
+	* @param request - prompt request
+	*/
+	prompt(request) {
+		return _prompt(this.#client, this.#httpRequest, request);
+	}
+	/**
+	* Patch a document using a schema aware API.
+	* Does not use an LLM, but uses the schema to ensure paths and values matches the schema.
+	* @param request - instruction request
+	*/
+	patch(request) {
+		return _patch(this.#client, this.#httpRequest, request);
+	}
+}, ObservableAssetsClient = class {
+	#client;
+	#httpRequest;
+	constructor(client, httpRequest) {
+		this.#client = client, this.#httpRequest = httpRequest;
+	}
+	upload(assetType, body, options) {
+		return _upload(this.#client, this.#httpRequest, assetType, body, options);
+	}
+}, AssetsClient = class {
+	#client;
+	#httpRequest;
+	constructor(client, httpRequest) {
+		this.#client = client, this.#httpRequest = httpRequest;
+	}
+	upload(assetType, body, options) {
+		let observable = _upload(this.#client, this.#httpRequest, assetType, body, options);
+		return lastValueFrom(observable.pipe(filter((event) => event.type === "response"), map$1((event) => pluckUploadedAsset(event.body))));
+	}
+};
+/**
+* Content Lake's upload endpoint responds with `{document: ...}`; the Media
+* Library upload endpoint responds with `{asset: ...}` instead (a
+* `sanity.asset` document, not a Content Lake asset document). Narrowing on
+* the response body itself - rather than on the client's `resource` config -
+* keeps this correct regardless of how the two are ever wired together.
+*/
+function isMediaLibraryUploadBody(body) {
+	return "asset" in body;
+}
+function pluckUploadedAsset(body) {
+	return isMediaLibraryUploadBody(body) ? body.asset : body.document;
+}
+function _upload(client, _httpRequest, assetType, body, opts = {}) {
+	validateAssetType(assetType);
+	let meta = opts.extract || void 0;
+	meta && !meta.length && (meta = ["none"]);
+	let config = client.config(), options = optionsFromFile(opts, body), { tag, label, title, description, creditLine, filename, source } = options, isMediaLibrary = config.resource?.type === "media-library", query = isMediaLibrary ? {
+		title,
+		filename
+	} : {
+		label,
+		title,
+		description,
+		filename,
+		meta,
+		creditLine
+	};
+	source && !isMediaLibrary && (query.sourceId = source.id, query.sourceName = source.name, query.sourceUrl = source.url);
+	let headers = options.contentType ? { "Content-Type": options.contentType } : {}, baseRequest = {
+		tag,
+		method: "POST",
+		timeout: options.timeout || 0,
+		url: buildAssetUploadUrl(config, assetType),
+		headers,
+		query,
+		body
+	};
+	return typeof XMLHttpRequest < "u" ? defer(async () => {
+		let { uploadWithProgress } = await import("./browserUpload-2tz6Sdqp.js"), req = _prepareRequest(client, { ...baseRequest });
+		return uploadWithProgress({
+			url: appendQuery(req.url, req.query),
+			method: req.method ?? "POST",
+			headers: req.headers,
+			body,
+			withCredentials: req.credentials === "include",
+			timeout: typeof req.timeout == "object" ? req.timeout.total : req.timeout,
+			signal: req.signal
+		});
+	}).pipe(mergeAll()) : _uploadObservable(client, baseRequest);
+}
+function appendQuery(url, query) {
+	if (!query) return url;
+	let qs = (query instanceof URLSearchParams ? query : new URLSearchParams(Object.entries(query).flatMap(([key, value]) => value == null ? [] : [[key, `${value}`]]))).toString();
+	return qs ? url + (url.includes("?") ? "&" : "?") + qs : url;
+}
+function buildAssetUploadUrl(config, assetType) {
+	let assetTypeEndpoint = assetType === "image" ? "images" : "files", resource = config.resource;
+	if (resource) {
+		let { type, id } = resource;
+		switch (type) {
+			case "dataset": throw Error("Assets are not supported for dataset resources, yet. Configure the client with `{projectId: <projectId>, dataset: <datasetId>}` instead.");
+			case "canvas": return `/canvases/${id}/assets/${assetTypeEndpoint}`;
+			case "media-library": return `/media-libraries/${id}/upload`;
+			case "dashboard": return `/dashboards/${id}/assets/${assetTypeEndpoint}`;
+			default: throw Error(`Unsupported resource type: ${type.toString()}`);
+		}
+	}
+	return `assets/${assetTypeEndpoint}/${hasDataset(config)}`;
+}
+function optionsFromFile(opts, file) {
+	return typeof File > "u" || !(file instanceof File) ? opts : Object.assign({
+		filename: opts.preserveFilename === !1 ? void 0 : file.name,
+		contentType: file.type
+	}, opts);
+}
+var defaults_default = (obj, defaults) => Object.keys(defaults).concat(Object.keys(obj)).reduce((target, prop) => (target[prop] = obj[prop] === void 0 ? defaults[prop] : obj[prop], target), {});
+const pick = (obj, props) => props.reduce((selection, prop) => (obj[prop] === void 0 || (selection[prop] = obj[prop]), selection), {}), RETRYABLE_STATUSES = /* @__PURE__ */ new Set([408, 429]);
+/**
+* Note: connection failure is not the same as network disconnect which may happen more frequent.
+* The EventSource instance will automatically reconnect in case of a network disconnect, however,
+* in some rare cases a ConnectionFailed Error will be thrown and this operator explicitly retries these
+*/
+function reconnectOnConnectionFailure() {
+	return function(source) {
+		return source.pipe(catchError((err, caught) => err instanceof ConnectionFailedError && (typeof err.status != "number" || err.status < 400 || err.status >= 500 || RETRYABLE_STATUSES.has(err.status)) ? concat(of({ type: "reconnect" }), timer(1e3).pipe(mergeMap(() => caught))) : throwError(() => err)));
+	};
+}
+/**
+* Build a `fetch` implementation suitable for the `eventsource` package's
+* `fetch` option. Routes the EventSource connection through the same
+* transport layer the rest of the client uses, so things like the
+* test-fetch override, the per-request `proxy` config, and `HTTPS_PROXY`
+* env-var support apply to SSE too.
+*
+* Resolution order on each request:
+*
+*   1. `config.resolveFetch(config.proxy)` if set — the client's fetch
+*      resolver, so SSE uses the same transport as regular requests:
+*      custom fetch variants (incl. the test suite's injected mock),
+*      undici configuration, an explicit `proxy` config, and env-proxy
+*      support all apply to SSE too. The Node entry supplies get-it's
+*      undici-backed fetch (threading the resolver through the env
+*      instead of importing `get-it/node` directly keeps `undici` out of
+*      the browser bundle); the browser entry leaves it unset.
+*   2. `globalThis.fetch`. Note that Node's global fetch does NOT read
+*      proxy env vars (that is opt-in via `NODE_USE_ENV_PROXY`), which
+*      is one of the reasons step 1 exists.
+*
+* The returned fetch always merges `options.headers` into the outgoing
+* request, regardless of which underlying fetch was picked.
+*
+* @internal
+*/
+function resolveEventSourceFetch(config, options = {}) {
+	let extraHeaders = options.headers, credentials = options.withCredentials ? "include" : void 0;
+	return function eventSourceFetch(url, init) {
+		let baseFetch = pickBaseFetch(config), mergedInit = { ...init };
+		if (extraHeaders) {
+			let headers = new Headers(init?.headers);
+			for (let [key, value] of Object.entries(extraHeaders)) headers.set(key, value);
+			mergedInit.headers = headers;
+		}
+		return credentials !== void 0 && (mergedInit.credentials = credentials), baseFetch(typeof url == "string" ? url : url.href, mergedInit);
+	};
+}
+/**
+* The fetch the client's own transport resolves for this config: the
+* configured `resolveFetch` (honouring an explicit `proxy`) if present,
+* otherwise the global fetch. Shared by the EventSource connection and the
+* `/check/cors` probe so both resolve identically.
+*
+* @internal
+*/
+function pickBaseFetch(config) {
+	return config.resolveFetch ? config.resolveFetch(typeof config.proxy == "string" ? config.proxy : void 0) : globalThis.fetch.bind(globalThis);
+}
+const possibleOptions = [
+	"includePreviousRevision",
+	"includeResult",
+	"includeMutations",
+	"includeAllVersions",
+	"visibility",
+	"effectFormat",
+	"enableResume",
+	"tag"
+], defaultOptions = { includeResult: !0 };
+/** @public */
+function _listen(query, params, opts = {}) {
+	let config = this.config(), { url, token, withCredentials, requestTagPrefix, headers: configHeaders } = config, tag = opts.tag && requestTagPrefix ? [requestTagPrefix, opts.tag].join(".") : opts.tag, options = {
+		...defaults_default(opts, defaultOptions),
+		tag
+	}, listenOpts = pick(options, possibleOptions), qs = encodeQueryString({
+		query,
+		params,
+		options: {
+			tag,
+			...listenOpts
+		}
+	}), uri = `${url}${_getDataUrl(this, "listen", qs)}`;
+	if (uri.length > 14800) return throwError(() => /* @__PURE__ */ Error("Query too large for listener"));
+	let listenFor = options.events ? options.events : ["mutation"], headers = {};
+	token && (headers.Authorization = `Bearer ${token}`), configHeaders && Object.assign(headers, configHeaders);
+	let initEventSource = () => new EventSource(uri, { fetch: resolveEventSourceFetch(config, {
+		headers: Object.keys(headers).length ? headers : void 0,
+		withCredentials
+	}) });
+	return connectEventSource(initEventSource, listenFor).pipe(reconnectOnConnectionFailure(), filter((event) => listenFor.includes(event.type)), map$1((event) => ({
+		type: event.type,
+		..."data" in event ? event.data : {}
+	})));
+}
+/**
+* A variant of share that takes a predicate function to determine which value to replay to new subscribers
+* @param configOrPredicate - Predicate function to determine which value to replay
+* @param config - Optional ShareConfig
+*/
+function shareReplayLatest(configOrPredicate, config) {
+	return _shareReplayLatest(typeof configOrPredicate == "function" ? {
+		predicate: configOrPredicate,
+		...config
+	} : configOrPredicate);
+}
+function _shareReplayLatest(config) {
+	return (source) => {
+		let latest, emitted = !1, { predicate, ...shareConfig } = config, wrapped = source.pipe(tap((value) => {
+			config.predicate(value) && (emitted = !0, latest = value);
+		}), finalize(() => {
+			emitted = !1, latest = void 0;
+		}), share(shareConfig)), emitLatest = new Observable((subscriber) => {
+			emitted && subscriber.next(latest), subscriber.complete();
+		});
+		return merge(wrapped, emitLatest);
+	};
+}
+const requiredApiVersion = "2021-03-25";
+/**
+* @public
+*/
+var LiveClient = class {
+	#client;
+	constructor(client) {
+		this.#client = client;
+	}
+	/**
+	* Requires `apiVersion` to be `2021-03-25` or later.
+	*/
+	events({ includeDrafts = !1, tag: _tag, waitFor } = {}) {
+		let config = this.#client.config(), { projectId, apiVersion: _apiVersion, token, withCredentials, requestTagPrefix, headers: configHeaders } = config, apiVersion = _apiVersion.replace(/^v/, "");
+		if (apiVersion !== "X" && apiVersion < requiredApiVersion) throw Error(`The live events API requires API version ${requiredApiVersion} or later. The current API version is ${apiVersion}. Please update your API version to use this feature.`);
+		if (includeDrafts && !token && !withCredentials) throw Error("The live events API requires a token or withCredentials when 'includeDrafts: true'. Please update your client configuration. The token should have the lowest possible access role.");
+		let path = _getDataUrl(this.#client, "live/events"), url = new URL(this.#client.getUrl(path, !1)), tag = _tag && requestTagPrefix ? [requestTagPrefix, _tag].join(".") : _tag;
+		tag && url.searchParams.set("tag", tag), includeDrafts && url.searchParams.set("includeDrafts", "true"), waitFor && url.searchParams.set("waitFor", waitFor);
+		let eventSourceHeaders = {};
+		includeDrafts && token && (eventSourceHeaders.Authorization = `Bearer ${token}`), configHeaders && Object.assign(eventSourceHeaders, configHeaders);
+		let eventSourceWithCredentials = !!(includeDrafts && withCredentials), transportCache = eventsCache.get(config.resolveFetch);
+		transportCache || (transportCache = /* @__PURE__ */ new Map(), eventsCache.set(config.resolveFetch, transportCache));
+		let cacheKey = JSON.stringify([
+			url.href,
+			typeof config.proxy == "string" ? config.proxy : null,
+			eventSourceHeaders,
+			eventSourceWithCredentials
+		]), existing = transportCache.get(cacheKey);
+		if (existing) return existing;
+		let initEventSource = () => new EventSource(url.href, { fetch: resolveEventSourceFetch(config, {
+			headers: Object.keys(eventSourceHeaders).length ? eventSourceHeaders : void 0,
+			withCredentials: eventSourceWithCredentials
+		}) }), events = connectEventSource(initEventSource, [
+			"message",
+			"restart",
+			"welcome",
+			"reconnect",
+			"goaway"
+		]), checkCors = checkCorsObservable(new URL(this.#client.getUrl("/check/cors", !1)), projectId, eventSourceWithCredentials, pickBaseFetch(config)), observable = events.pipe(reconnectOnConnectionFailure(), mergeMap((event) => event.type === "reconnect" ? checkCors.pipe(mergeMap(() => of(event))) : of(event)), catchError((err) => err instanceof CorsOriginError ? throwError(() => err) : checkCors.pipe(mergeMap(() => {
+			throw err;
+		}))), map$1((event) => {
+			if (event.type === "message") {
+				let { data, ...rest } = event;
+				return {
+					...rest,
+					tags: data.tags
+				};
+			}
+			return event;
+		})).pipe(finalize$1(() => {
+			transportCache.delete(cacheKey), transportCache.size === 0 && eventsCache.delete(config.resolveFetch);
+		}), shareReplayLatest({ predicate: (event) => event.type === "welcome" }));
+		return transportCache.set(cacheKey, observable), observable;
+	}
+};
+/**
+* Probes the `/check/cors` endpoint to confirm whether the current origin is
+* allowed by the project's CORS configuration. EventSource failures are opaque,
+* so we use this side-channel purely to tell "the server actively rejected our
+* origin" apart from every other class of failure.
+*
+* Errors with `CorsOriginError` when either:
+*
+* - `requireCredentials` is `true` (the EventSource was about to send
+*   credentials) and `/check/cors` reports `result.withCredentials === false`.
+*   The credentialed request would fail due to a missing
+*   `access-control-allow-credentials` header. The resulting error carries
+*   `credentials: true` so its `addOriginUrl` deep-link pre-selects the
+*   "Allow credentials" toggle in the Sanity management form.
+* - `/check/cors` reports `result.allowed === false` (origin is not on the
+*   project's CORS allow-list). The error carries `credentials: requireCredentials`
+*   so the deep-link still pre-selects credentials when the caller needed them.
+*
+* Every other outcome is intentionally treated as "we don't know": the
+* observable emits a single `void` value and then completes, so downstream
+* `mergeMap(() => ...)` consumers can continue. No error is surfaced for any
+* of these cases:
+*
+* - `allowed: true` (with credentials satisfied if required) or an
+*   unrecognised body shape: the server did not confirm a CORS rejection.
+* - Non-2xx HTTP response from `/check/cors`: same - no signal either way, and
+*   a 5xx on the probe shouldn't poison the EventSource's original error.
+* - `fetch` / network / JSON parse failures: indistinguishable from ordinary
+*   connectivity hiccups (offline, DNS, certs, transient outages). Reporting
+*   those as CORS errors is exactly the false-positive class this helper
+*   exists to prevent.
+* - The subscription was aborted: nothing to emit and nothing to complete.
+*
+* In all of those cases the caller's original underlying error from the
+* EventSource is allowed to propagate unchanged.
+*/
+function checkCorsObservable(url, projectId, requireCredentials, fetcher) {
+	return new Observable((observer) => {
+		let controller = new AbortController(), { signal } = controller;
+		return fetcher(url.href, {
+			method: "GET",
+			credentials: "omit",
+			signal
+		}).then((response) => {
+			if (!(signal.aborted || !response.ok)) return response.text();
+		}).then((text) => {
+			if (signal.aborted) return;
+			let parsed = text === void 0 ? void 0 : JSON.parse(text), result = isRecord(parsed) ? parsed.result : void 0;
+			if (requireCredentials && isRecord(result) && result.withCredentials === !1) {
+				observer.error(new CorsOriginError({
+					projectId,
+					credentials: !0
+				}));
+				return;
+			}
+			if (isRecord(result) && result.allowed === !1) {
+				observer.error(new CorsOriginError({
+					projectId,
+					credentials: requireCredentials
+				}));
+				return;
+			}
+			observer.next(), observer.complete();
+		}).catch(() => {
+			signal.aborted || observer.closed || (observer.next(), observer.complete());
+		}), () => controller.abort();
+	});
+}
+/**
+* Cached observables capture their transport (`initEventSource` closes over
+* `config.resolveFetch` and `config.proxy`), so the cache is scoped per
+* resolver — `undefined` covers the `globalThis.fetch` fallback.
+*/
+const eventsCache = /* @__PURE__ */ new Map();
+/** @internal */
+var ObservableDatasetsClient = class {
+	#client;
+	#httpRequest;
+	constructor(client, httpRequest) {
+		this.#client = client, this.#httpRequest = httpRequest;
+	}
+	/**
+	* Create a new dataset with the given name
+	*
+	* @param name - Name of the dataset to create
+	* @param options - Options for the dataset, including optional embeddings configuration
+	*/
+	create(name, options) {
+		return _modifyObservable(this.#client, this.#httpRequest, "PUT", name, options);
+	}
+	/**
+	* Edit a dataset with the given name
+	*
+	* @param name - Name of the dataset to edit
+	* @param options - New options for the dataset
+	*/
+	edit(name, options) {
+		return _modifyObservable(this.#client, this.#httpRequest, "PATCH", name, options);
+	}
+	/**
+	* Delete a dataset with the given name
+	*
+	* @param name - Name of the dataset to delete
+	*/
+	delete(name) {
+		return _modifyObservable(this.#client, this.#httpRequest, "DELETE", name);
+	}
+	/**
+	* Fetch a list of datasets for the configured project
+	*/
+	list() {
+		resourceGuard("dataset", this.#client.config());
+		let config = this.#client.config(), projectId = config.projectId, url = "/datasets";
+		return config.useProjectHostname === !1 && (url = `/projects/${projectId}/datasets`), _requestObservable(this.#client, this.#httpRequest, {
+			url,
+			tag: null
+		});
+	}
+	/**
+	* Get embeddings settings for a dataset
+	*
+	* @param name - Name of the dataset
+	*/
+	getEmbeddingsSettings(name) {
+		return resourceGuard("dataset", this.#client.config()), dataset(name), _requestObservable(this.#client, this.#httpRequest, {
+			url: _embeddingsSettingsUri(this.#client, name),
+			tag: null
+		});
+	}
+	/**
+	* Edit embeddings settings for a dataset
+	*
+	* @param name - Name of the dataset
+	* @param settings - Embeddings settings to apply
+	*/
+	editEmbeddingsSettings(name, settings) {
+		return resourceGuard("dataset", this.#client.config()), dataset(name), _requestObservable(this.#client, this.#httpRequest, {
+			method: "PUT",
+			url: _embeddingsSettingsUri(this.#client, name),
+			body: settings,
+			tag: null
+		});
+	}
+}, DatasetsClient = class {
+	#client;
+	#httpRequest;
+	constructor(client, httpRequest) {
+		this.#client = client, this.#httpRequest = httpRequest;
+	}
+	/**
+	* Create a new dataset with the given name
+	*
+	* @param name - Name of the dataset to create
+	* @param options - Options for the dataset, including optional embeddings configuration
+	*/
+	create(name, options) {
+		return resourceGuard("dataset", this.#client.config()), _modify(this.#client, this.#httpRequest, "PUT", name, options);
+	}
+	/**
+	* Edit a dataset with the given name
+	*
+	* @param name - Name of the dataset to edit
+	* @param options - New options for the dataset
+	*/
+	edit(name, options) {
+		return resourceGuard("dataset", this.#client.config()), _modify(this.#client, this.#httpRequest, "PATCH", name, options);
+	}
+	/**
+	* Delete a dataset with the given name
+	*
+	* @param name - Name of the dataset to delete
+	*/
+	delete(name) {
+		return resourceGuard("dataset", this.#client.config()), _modify(this.#client, this.#httpRequest, "DELETE", name);
+	}
+	/**
+	* Fetch a list of datasets for the configured project
+	*/
+	list() {
+		resourceGuard("dataset", this.#client.config());
+		let config = this.#client.config(), projectId = config.projectId, url = "/datasets";
+		return config.useProjectHostname === !1 && (url = `/projects/${projectId}/datasets`), _request(this.#client, this.#httpRequest, {
+			url,
+			tag: null
+		});
+	}
+	/**
+	* Get embeddings settings for a dataset
+	*
+	* @param name - Name of the dataset
+	*/
+	getEmbeddingsSettings(name) {
+		return resourceGuard("dataset", this.#client.config()), dataset(name), _request(this.#client, this.#httpRequest, {
+			url: _embeddingsSettingsUri(this.#client, name),
+			tag: null
+		});
+	}
+	/**
+	* Edit embeddings settings for a dataset
+	*
+	* @param name - Name of the dataset
+	* @param settings - Embeddings settings to apply
+	*/
+	editEmbeddingsSettings(name, settings) {
+		return resourceGuard("dataset", this.#client.config()), dataset(name), _request(this.#client, this.#httpRequest, {
+			method: "PUT",
+			url: _embeddingsSettingsUri(this.#client, name),
+			body: settings,
+			tag: null
+		});
+	}
+};
+function _embeddingsSettingsUri(client, name) {
+	let config = client.config();
+	return config.useProjectHostname === !1 ? `/projects/${config.projectId}/datasets/${name}/settings/embeddings` : `/datasets/${name}/settings/embeddings`;
+}
+function _modifyObservable(client, httpRequest, method, name, options) {
+	return resourceGuard("dataset", client.config()), dataset(name), _requestObservable(client, httpRequest, {
+		method,
+		url: `/datasets/${name}`,
+		body: options,
+		tag: null
+	});
+}
+function _modify(client, httpRequest, method, name, options) {
+	return resourceGuard("dataset", client.config()), dataset(name), _request(client, httpRequest, {
+		method,
+		url: `/datasets/${name}`,
+		body: options,
+		tag: null
+	});
+}
+/** Function resource types in a blueprint are namespaced under this prefix. */
+const scopeHeaders = (config, request) => {
+	let organizationId = request?.organizationId || config.organizationId;
+	if (organizationId) return {
+		"X-Sanity-Scope-Type": "organization",
+		"X-Sanity-Scope-Id": organizationId
+	};
+	let { projectId } = config;
+	if (!projectId) throw Error("`functions.invoke()` requires a `projectId` to be set in the client config, or an `organizationId` for a stack deployed at organization scope");
+	return {
+		"X-Sanity-Scope-Type": "project",
+		"X-Sanity-Scope-Id": projectId
+	};
+}, resolveStackId = (config, request) => {
+	let stackId = request?.stackId || config.stackId;
+	if (!stackId) throw Error("`functions.invoke()` requires a `stackId`, either in the client config or on the request. Function names are only unique within a stack.");
+	return stackId;
+};
+/**
+* The invoke route is keyed by function id, but callers know functions by the
+* name declared in the blueprint. Names are unique within a stack, so the stack
+* both makes the name resolvable and confines the call to its own functions.
+*
+* @internal
+*/
+function _resolveFunctionId(client, httpRequest, functionName, stackId, headers, request) {
+	return _requestObservable(client, httpRequest, {
+		method: "GET",
+		url: `/blueprints/stacks/${stackId}`,
+		headers,
+		signal: request?.signal
+	}).pipe(map((stack) => {
+		let match = (stack?.resources || []).find((resource) => resource.type?.startsWith("sanity.function.") && resource.name === functionName);
+		if (!match) throw Error(`Function "${functionName}" not found in stack "${stackId}"`);
+		if (!match.externalId) throw Error(`Function "${functionName}" is declared in stack "${stackId}" but is not deployed`);
+		if (match.type !== "sanity.function.pubsub") throw Error(`Function invocation is not supported for ${match.type}`);
+		return match.externalId;
+	}));
+}
+/** @internal */
+function _invoke(client, httpRequest, functionName, request) {
+	return defer(() => {
+		let config = client.config(), headers = scopeHeaders(config, request);
+		return _resolveFunctionId(client, httpRequest, functionName, resolveStackId(config, request), headers, request).pipe(mergeMap((functionId) => _requestObservable(client, httpRequest, {
+			method: "POST",
+			url: `/functions/${functionId}/invoke`,
+			headers,
+			body: { event: { data: request?.event?.data ?? {} } },
+			timeout: request?.timeout,
+			signal: request?.signal
+		})));
+	});
+}
+/** @public */
+var ObservableFunctionsClient = class {
+	#client;
+	#httpRequest;
+	constructor(client, httpRequest) {
+		this.#client = client, this.#httpRequest = httpRequest;
+	}
+	/**
+	* Invoke a deployed function by its blueprint name.
+	*
+	* The name is resolved within the stack given by `stackId` on the request or
+	* the client config. Passes the function's return value once it finishes.
+	*
+	* @param functionName - name of the function, as declared in the blueprint
+	* @param request - payload and request options
+	*/
+	invoke(functionName, request) {
+		return _invoke(this.#client, this.#httpRequest, functionName, request);
+	}
+}, FunctionsClient = class {
+	#client;
+	#httpRequest;
+	constructor(client, httpRequest) {
+		this.#client = client, this.#httpRequest = httpRequest;
+	}
+	/**
+	* Invoke a deployed function by its blueprint name.
+	*
+	* The name is resolved within the stack given by `stackId` on the request or
+	* the client config, which costs one extra request per call. Rejects if the
+	* stack has no function by that name, or if the name resolves to anything
+	* other than a `sanity.function.pubsub` function.
+	*
+	* The lookup is scoped to `projectId`, or to `organizationId` when one is set
+	* for a stack deployed at organization scope.
+	*
+	* The request stays open until the function finishes, and resolves with its
+	* return value, or `undefined` if it returns nothing. Long-running functions
+	* may need an explicit `timeout`.
+	*
+	* @param functionName - name of the function, as declared in the blueprint
+	* @param request - payload and request options
+	*/
+	invoke(functionName, request) {
+		return lastValueFrom(_invoke(this.#client, this.#httpRequest, functionName, request));
+	}
+}, ObservableMediaLibraryVideoClient = class {
+	#client;
+	#httpRequest;
+	constructor(client, httpRequest) {
+		this.#client = client, this.#httpRequest = httpRequest;
+	}
+	/**
+	* Get video playback information for a media library asset
+	*
+	* @param assetIdentifier - Asset instance identifier (GDR, video-prefixed ID, or container ID)
+	* @param options - Options for transformations and expiration
+	*/
+	getPlaybackInfo(assetIdentifier, options = {}) {
+		let config = this.#client.config(), configMediaLibraryId = (config.resource || config["~experimental_resource"])?.id, { instanceId, libraryId } = parseAssetInstanceId(assetIdentifier), effectiveLibraryId = libraryId || configMediaLibraryId;
+		if (!effectiveLibraryId) throw Error("Could not determine Media Library ID - you need to provide a valid Media Library ID in the client config or a Media Library GDR");
+		let url = buildVideoPlaybackInfoUrl(instanceId, effectiveLibraryId), queryParams = buildQueryParams(options);
+		return _requestObservable(this.#client, this.#httpRequest, {
+			method: "GET",
+			url,
+			query: queryParams
+		});
+	}
+}, MediaLibraryVideoClient = class {
+	#client;
+	#httpRequest;
+	constructor(client, httpRequest) {
+		this.#client = client, this.#httpRequest = httpRequest;
+	}
+	/**
+	* Get video playback information for a media library asset
+	*
+	* @param assetIdentifier - Asset instance identifier (GDR, video-prefixed ID, or container ID)
+	* @param options - Options for transformations and expiration
+	*/
+	getPlaybackInfo(assetIdentifier, options = {}) {
+		let config = this.#client.config(), configMediaLibraryId = (config.resource || config["~experimental_resource"])?.id, { instanceId, libraryId } = parseAssetInstanceId(assetIdentifier), effectiveLibraryId = libraryId || configMediaLibraryId;
+		if (!effectiveLibraryId) throw Error("Could not determine Media Library ID - you need to provide a valid Media Library ID in the client config or a Media Library GDR");
+		let url = buildVideoPlaybackInfoUrl(instanceId, effectiveLibraryId), queryParams = buildQueryParams(options);
+		return _request(this.#client, this.#httpRequest, {
+			method: "GET",
+			url,
+			query: queryParams
+		});
+	}
+};
+const ML_GDR_PATTERN = /^media-library:(ml[^:]+):([^:]+)$/;
+/** @internal */
+function isSanityReference(assetIdentifier) {
+	return typeof assetIdentifier == "object" && "_ref" in assetIdentifier;
+}
+/**
+* Parse the asset instance id and library id from the asset identifier
+*
+* @param assetIdentifier - The asset identifier - either a asset instance id or a Media Library GDR
+* @returns The asset instance id and library id
+*/
+function parseAssetInstanceId(assetIdentifier) {
+	let ref = isSanityReference(assetIdentifier) ? assetIdentifier._ref : assetIdentifier, match = ML_GDR_PATTERN.exec(ref);
+	if (match) {
+		let [, libraryId, instanceId] = match;
+		return {
+			libraryId,
+			instanceId
+		};
+	}
+	if (typeof assetIdentifier == "string" && assetIdentifier.startsWith("video-")) return { instanceId: assetIdentifier };
+	throw Error(`Invalid video asset instance identifier "${ref}": must be a valid video instance id or a Global Dataset Reference (GDR) to the video asset in the Media Library`);
+}
+function buildVideoPlaybackInfoUrl(instanceId, libraryId) {
+	return `/media-libraries/${libraryId}/video/${instanceId}/playback-info`;
+}
+function buildQueryParams(options) {
+	let params = {};
+	if (options.transformations) {
+		let { thumbnail, animated, storyboard } = options.transformations;
+		thumbnail && (thumbnail.width && (params.thumbnailWidth = thumbnail.width), thumbnail.height && (params.thumbnailHeight = thumbnail.height), thumbnail.time !== void 0 && (params.thumbnailTime = thumbnail.time), thumbnail.fit && (params.thumbnailFit = thumbnail.fit), thumbnail.format && (params.thumbnailFormat = thumbnail.format)), animated && (animated.width && (params.animatedWidth = animated.width), animated.height && (params.animatedHeight = animated.height), animated.start !== void 0 && (params.animatedStart = animated.start), animated.end !== void 0 && (params.animatedEnd = animated.end), animated.fps && (params.animatedFps = animated.fps), animated.format && (params.animatedFormat = animated.format)), storyboard && storyboard.format && (params.storyboardFormat = storyboard.format);
+	}
+	return options.expiration && (params.expiration = options.expiration), params;
+}
+/** @internal */
+var ObservableProjectsClient = class {
+	#client;
+	#httpRequest;
+	constructor(client, httpRequest) {
+		this.#client = client, this.#httpRequest = httpRequest;
+	}
+	/**
+	* Fetch a list of projects the authenticated user has access to.
+	*
+	* @param options - Options for the list request
+	*   - `includeMembers` - Whether to include members in the response (default: true)
+	*   - `includeFeatures` - Whether to include features in the response (default: true)
+	*   - `organizationId` - ID of the organization to fetch projects for
+	*   - `onlyExplicitMembership` - Whether to include only projects with explicit membership (default: false)
+	*/
+	list(options) {
+		let query = {};
+		return options?.includeMembers === !1 && (query.includeMembers = "false"), options?.includeFeatures === !1 && (query.includeFeatures = "false"), options?.organizationId && (query.organizationId = options.organizationId), options?.onlyExplicitMembership && (query.onlyExplicitMembership = "true"), _requestObservable(this.#client, this.#httpRequest, {
+			url: "/projects",
+			query
+		});
+	}
+	/**
+	* Fetch a project by project ID
+	*
+	* @param projectId - ID of the project to fetch
+	*/
+	getById(projectId) {
+		return _requestObservable(this.#client, this.#httpRequest, { url: `/projects/${projectId}` });
+	}
+}, ProjectsClient = class {
+	#client;
+	#httpRequest;
+	constructor(client, httpRequest) {
+		this.#client = client, this.#httpRequest = httpRequest;
+	}
+	/**
+	* Fetch a list of projects the authenticated user has access to.
+	*
+	* @param options - Options for the list request
+	*   - `includeMembers` - Whether to include members in the response (default: true)
+	*   - `includeFeatures` - Whether to include features in the response (default: true)
+	*   - `organizationId` - ID of the organization to fetch projects for
+	*   - `onlyExplicitMembership` - Whether to include only projects with explicit membership (default: false)
+	*/
+	list(options) {
+		let query = {};
+		return options?.includeMembers === !1 && (query.includeMembers = "false"), options?.includeFeatures === !1 && (query.includeFeatures = "false"), options?.organizationId && (query.organizationId = options.organizationId), options?.onlyExplicitMembership && (query.onlyExplicitMembership = "true"), _request(this.#client, this.#httpRequest, {
+			url: "/projects",
+			query
+		});
+	}
+	/**
+	* Fetch a project by project ID
+	*
+	* @param projectId - ID of the project to fetch
+	*/
+	getById(projectId) {
+		return _request(this.#client, this.#httpRequest, { url: `/projects/${projectId}` });
+	}
+};
+/**
+* @internal
+*
+* ~24 years (or 7.54e+8 seconds) needed, in order to have a 1% probability of at least one collision if 10 ID's are generated every hour.
+*/
+const generateReleaseId = customAlphabet("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789", 8), getDocumentVersionId = (publishedId, releaseId) => releaseId ? getVersionId(publishedId, releaseId) : getDraftId(publishedId);
+/** @internal */
+function deriveDocumentVersionId(op, { releaseId, publishedId, document }) {
+	if (publishedId && document._id) {
+		let versionId = getDocumentVersionId(publishedId, releaseId);
+		return validateVersionIdMatch(versionId, document), versionId;
+	}
+	if (document._id) {
+		let isDraft = isDraftId(document._id), isVersion = isVersionId(document._id);
+		if (!isDraft && !isVersion) throw Error(`\`${op}()\` requires a document with an \`_id\` that is a version or draft ID`);
+		if (releaseId) {
+			if (isDraft) throw Error(`\`${op}()\` was called with a document ID (\`${document._id}\`) that is a draft ID, but a release ID (\`${releaseId}\`) was also provided.`);
+			let builtVersionId = getVersionFromId(document._id);
+			if (builtVersionId !== releaseId) throw Error(`\`${op}()\` was called with a document ID (\`${document._id}\`) that is a version ID, but the release ID (\`${releaseId}\`) does not match the document's version ID (\`${builtVersionId}\`).`);
+		}
+		return document._id;
+	}
+	if (publishedId) return getDocumentVersionId(publishedId, releaseId);
+	throw Error(`\`${op}()\` requires either a publishedId or a document with an \`_id\``);
+}
+const getArgs = (releaseOrOptions, maybeOptions) => {
+	if (typeof releaseOrOptions == "object" && releaseOrOptions && ("releaseId" in releaseOrOptions || "metadata" in releaseOrOptions)) {
+		let { releaseId = generateReleaseId(), metadata = {} } = releaseOrOptions;
+		return [
+			releaseId,
+			metadata,
+			maybeOptions
+		];
+	}
+	return [
+		generateReleaseId(),
+		{},
+		releaseOrOptions
+	];
+}, createRelease = (releaseOrOptions, maybeOptions) => {
+	let [releaseId, metadata, options] = getArgs(releaseOrOptions, maybeOptions);
+	return {
+		action: {
+			actionType: "sanity.action.release.create",
+			releaseId,
+			metadata: {
+				...metadata,
+				releaseType: metadata.releaseType || "undecided"
+			}
+		},
+		options
+	};
+};
+/** @public */
+var ObservableReleasesClient = class {
+	#client;
+	#httpRequest;
+	constructor(client, httpRequest) {
+		this.#client = client, this.#httpRequest = httpRequest;
+	}
+	/**
+	* @public
+	*
+	* Retrieve a release by id.
+	*
+	* @category Releases
+	*
+	* @param params - Release action parameters:
+	*   - `releaseId` - The id of the release to retrieve.
+	* @param options - Additional query options including abort signal and query tag.
+	* @returns An observable that resolves to the release document {@link ReleaseDocument}.
+	*
+	* @example Retrieving a release by id
+	* ```ts
+	* client.observable.releases.get({releaseId: 'my-release'}).pipe(
+	*   tap((release) => console.log(release)),
+	*   // {
+	*   //   _id: '_.releases.my-release',
+	*   //   name: 'my-release'
+	*   //   _type: 'system.release',
+	*   //   metadata: {releaseType: 'asap'},
+	*   //   _createdAt: '2021-01-01T00:00:00.000Z',
+	*   //   ...
+	*   // }
+	* ).subscribe()
+	* ```
+	*/
+	get({ releaseId }, options) {
+		return _getDocumentObservable(this.#client, this.#httpRequest, `_.releases.${releaseId}`, options);
+	}
+	create(releaseOrOptions, maybeOptions) {
+		let { action, options } = createRelease(releaseOrOptions, maybeOptions), { releaseId, metadata } = action;
+		return _actionObservable(this.#client, this.#httpRequest, action, options).pipe(map((actionResult) => ({
+			...actionResult,
+			releaseId,
+			metadata
+		})));
+	}
+	/**
+	* @public
+	*
+	* Edits an existing release, updating the metadata.
+	*
+	* @category Releases
+	*
+	* @param params - Release action parameters:
+	*   - `releaseId` - The id of the release to edit.
+	*   - `patch` - The patch operation to apply on the release metadata {@link PatchMutationOperation}.
+	* @param options - Additional action options.
+	* @returns An observable that resolves to the `transactionId`.
+	*/
+	edit({ releaseId, patch }, options) {
+		let editAction = {
+			actionType: "sanity.action.release.edit",
+			releaseId,
+			patch
+		};
+		return _actionObservable(this.#client, this.#httpRequest, editAction, options);
+	}
+	/**
+	* @public
+	*
+	* Publishes all documents in a release at once. For larger releases the effect of the publish
+	* will be visible immediately when querying but the removal of the `versions.<releasesId>.*`
+	* documents and creation of the corresponding published documents with the new content may
+	* take some time.
+	*
+	* During this period both the source and target documents are locked and cannot be
+	* modified through any other means.
+	*
+	* @category Releases
+	*
+	* @param params - Release action parameters:
+	*   - `releaseId` - The id of the release to publish.
+	* @param options - Additional action options.
+	* @returns An observable that resolves to the `transactionId`.
+	*/
+	publish({ releaseId }, options) {
+		let publishAction = {
+			actionType: "sanity.action.release.publish",
+			releaseId
+		};
+		return _actionObservable(this.#client, this.#httpRequest, publishAction, options);
+	}
+	/**
+	* @public
+	*
+	* An archive action removes an active release. The documents that comprise the release
+	* are deleted and therefore no longer queryable.
+	*
+	* While the documents remain in retention the last version can still be accessed using document history endpoint.
+	*
+	* @category Releases
+	*
+	* @param params - Release action parameters:
+	*   - `releaseId` - The id of the release to archive.
+	* @param options - Additional action options.
+	* @returns An observable that resolves to the `transactionId`.
+	*/
+	archive({ releaseId }, options) {
+		let archiveAction = {
+			actionType: "sanity.action.release.archive",
+			releaseId
+		};
+		return _actionObservable(this.#client, this.#httpRequest, archiveAction, options);
+	}
+	/**
+	* @public
+	*
+	* An unarchive action restores an archived release and all documents
+	* with the content they had just prior to archiving.
+	*
+	* @category Releases
+	*
+	* @param params - Release action parameters:
+	*   - `releaseId` - The id of the release to unarchive.
+	* @param options - Additional action options.
+	* @returns An observable that resolves to the `transactionId`.
+	*/
+	unarchive({ releaseId }, options) {
+		let unarchiveAction = {
+			actionType: "sanity.action.release.unarchive",
+			releaseId
+		};
+		return _actionObservable(this.#client, this.#httpRequest, unarchiveAction, options);
+	}
+	/**
+	* @public
+	*
+	* A schedule action queues a release for publishing at the given future time.
+	* The release is locked such that no documents in the release can be modified and
+	* no documents that it references can be deleted as this would make the publish fail.
+	* At the given time, the same logic as for the publish action is triggered.
+	*
+	* @category Releases
+	*
+	* @param params - Release action parameters:
+	*   - `releaseId` - The id of the release to schedule.
+	*   - `publishAt` - The serialised date and time to publish the release. If the `publishAt` is in the past, the release will be published immediately.
+	* @param options - Additional action options.
+	* @returns An observable that resolves to the `transactionId`.
+	*/
+	schedule({ releaseId, publishAt }, options) {
+		let scheduleAction = {
+			actionType: "sanity.action.release.schedule",
+			releaseId,
+			publishAt
+		};
+		return _actionObservable(this.#client, this.#httpRequest, scheduleAction, options);
+	}
+	/**
+	* @public
+	*
+	* An unschedule action stops a release from being published.
+	* The documents in the release are considered unlocked and can be edited again.
+	* This may fail if another release is scheduled to be published after this one and
+	* has a reference to a document created by this one.
+	*
+	* @category Releases
+	*
+	* @param params - Release action parameters:
+	*   - `releaseId` - The id of the release to unschedule.
+	* @param options - Additional action options.
+	* @returns An observable that resolves to the `transactionId`.
+	*/
+	unschedule({ releaseId }, options) {
+		let unscheduleAction = {
+			actionType: "sanity.action.release.unschedule",
+			releaseId
+		};
+		return _actionObservable(this.#client, this.#httpRequest, unscheduleAction, options);
+	}
+	/**
+	* @public
+	*
+	* A delete action removes a published or archived release.
+	* The backing system document will be removed from the dataset.
+	*
+	* @category Releases
+	*
+	* @param params - Release action parameters:
+	*   - `releaseId` - The id of the release to delete.
+	* @param options - Additional action options.
+	* @returns An observable that resolves to the `transactionId`.
+	*/
+	delete({ releaseId }, options) {
+		let deleteAction = {
+			actionType: "sanity.action.release.delete",
+			releaseId
+		};
+		return _actionObservable(this.#client, this.#httpRequest, deleteAction, options);
+	}
+	/**
+	* @public
+	*
+	* Fetch the documents in a release by release id.
+	*
+	* @category Releases
+	*
+	* @param params - Release action parameters:
+	*   - `releaseId` - The id of the release to fetch documents for.
+	* @param options - Additional mutation options {@link BaseMutationOptions}.
+	* @returns An observable that resolves to the documents in the release.
+	*/
+	fetchDocuments({ releaseId }, options) {
+		return _getReleaseDocumentsObservable(this.#client, this.#httpRequest, releaseId, options);
+	}
+}, ReleasesClient = class {
+	#client;
+	#httpRequest;
+	constructor(client, httpRequest) {
+		this.#client = client, this.#httpRequest = httpRequest;
+	}
+	/**
+	* @public
+	*
+	* Retrieve a release by id.
+	*
+	* @category Releases
+	*
+	* @param params - Release action parameters:
+	*   - `releaseId` - The id of the release to retrieve.
+	* @param options - Additional query options including abort signal and query tag.
+	* @returns A promise that resolves to the release document {@link ReleaseDocument}.
+	*
+	* @example Retrieving a release by id
+	* ```ts
+	* const release = await client.releases.get({releaseId: 'my-release'})
+	* console.log(release)
+	* // {
+	* //   _id: '_.releases.my-release',
+	* //   name: 'my-release'
+	* //   _type: 'system.release',
+	* //   metadata: {releaseType: 'asap'},
+	* //   _createdAt: '2021-01-01T00:00:00.000Z',
+	* //   ...
+	* // }
+	* ```
+	*/
+	get({ releaseId }, options) {
+		return _getDocument(this.#client, this.#httpRequest, `_.releases.${releaseId}`, options);
+	}
+	async create(releaseOrOptions, maybeOptions) {
+		let { action, options } = createRelease(releaseOrOptions, maybeOptions), { releaseId, metadata } = action;
+		return {
+			...await _action(this.#client, this.#httpRequest, action, options),
+			releaseId,
+			metadata
+		};
+	}
+	/**
+	* @public
+	*
+	* Edits an existing release, updating the metadata.
+	*
+	* @category Releases
+	*
+	* @param params - Release action parameters:
+	*   - `releaseId` - The id of the release to edit.
+	*   - `patch` - The patch operation to apply on the release metadata {@link PatchMutationOperation}.
+	* @param options - Additional action options.
+	* @returns A promise that resolves to the `transactionId`.
+	*/
+	edit({ releaseId, patch }, options) {
+		let editAction = {
+			actionType: "sanity.action.release.edit",
+			releaseId,
+			patch
+		};
+		return _action(this.#client, this.#httpRequest, editAction, options);
+	}
+	/**
+	* @public
+	*
+	* Publishes all documents in a release at once. For larger releases the effect of the publish
+	* will be visible immediately when querying but the removal of the `versions.<releasesId>.*`
+	* documents and creation of the corresponding published documents with the new content may
+	* take some time.
+	*
+	* During this period both the source and target documents are locked and cannot be
+	* modified through any other means.
+	*
+	* @category Releases
+	*
+	* @param params - Release action parameters:
+	*   - `releaseId` - The id of the release to publish.
+	* @param options - Additional action options.
+	* @returns A promise that resolves to the `transactionId`.
+	*/
+	publish({ releaseId }, options) {
+		let publishAction = {
+			actionType: "sanity.action.release.publish",
+			releaseId
+		};
+		return _action(this.#client, this.#httpRequest, publishAction, options);
+	}
+	/**
+	* @public
+	*
+	* An archive action removes an active release. The documents that comprise the release
+	* are deleted and therefore no longer queryable.
+	*
+	* While the documents remain in retention the last version can still be accessed using document history endpoint.
+	*
+	* @category Releases
+	*
+	* @param params - Release action parameters:
+	*   - `releaseId` - The id of the release to archive.
+	* @param options - Additional action options.
+	* @returns A promise that resolves to the `transactionId`.
+	*/
+	archive({ releaseId }, options) {
+		let archiveAction = {
+			actionType: "sanity.action.release.archive",
+			releaseId
+		};
+		return _action(this.#client, this.#httpRequest, archiveAction, options);
+	}
+	/**
+	* @public
+	*
+	* An unarchive action restores an archived release and all documents
+	* with the content they had just prior to archiving.
+	*
+	* @category Releases
+	*
+	* @param params - Release action parameters:
+	*   - `releaseId` - The id of the release to unarchive.
+	* @param options - Additional action options.
+	* @returns A promise that resolves to the `transactionId`.
+	*/
+	unarchive({ releaseId }, options) {
+		let unarchiveAction = {
+			actionType: "sanity.action.release.unarchive",
+			releaseId
+		};
+		return _action(this.#client, this.#httpRequest, unarchiveAction, options);
+	}
+	/**
+	* @public
+	*
+	* A schedule action queues a release for publishing at the given future time.
+	* The release is locked such that no documents in the release can be modified and
+	* no documents that it references can be deleted as this would make the publish fail.
+	* At the given time, the same logic as for the publish action is triggered.
+	*
+	* @category Releases
+	*
+	* @param params - Release action parameters:
+	*   - `releaseId` - The id of the release to schedule.
+	*   - `publishAt` - The serialised date and time to publish the release. If the `publishAt` is in the past, the release will be published immediately.
+	* @param options - Additional action options.
+	* @returns A promise that resolves to the `transactionId`.
+	*/
+	schedule({ releaseId, publishAt }, options) {
+		let scheduleAction = {
+			actionType: "sanity.action.release.schedule",
+			releaseId,
+			publishAt
+		};
+		return _action(this.#client, this.#httpRequest, scheduleAction, options);
+	}
+	/**
+	* @public
+	*
+	* An unschedule action stops a release from being published.
+	* The documents in the release are considered unlocked and can be edited again.
+	* This may fail if another release is scheduled to be published after this one and
+	* has a reference to a document created by this one.
+	*
+	* @category Releases
+	*
+	* @param params - Release action parameters:
+	*   - `releaseId` - The id of the release to unschedule.
+	* @param options - Additional action options.
+	* @returns A promise that resolves to the `transactionId`.
+	*/
+	unschedule({ releaseId }, options) {
+		let unscheduleAction = {
+			actionType: "sanity.action.release.unschedule",
+			releaseId
+		};
+		return _action(this.#client, this.#httpRequest, unscheduleAction, options);
+	}
+	/**
+	* @public
+	*
+	* A delete action removes a published or archived release.
+	* The backing system document will be removed from the dataset.
+	*
+	* @category Releases
+	*
+	* @param params - Release action parameters:
+	*   - `releaseId` - The id of the release to delete.
+	* @param options - Additional action options.
+	* @returns A promise that resolves to the `transactionId`.
+	*/
+	delete({ releaseId }, options) {
+		let deleteAction = {
+			actionType: "sanity.action.release.delete",
+			releaseId
+		};
+		return _action(this.#client, this.#httpRequest, deleteAction, options);
+	}
+	/**
+	* @public
+	*
+	* Fetch the documents in a release by release id.
+	*
+	* @category Releases
+	*
+	* @param params - Release action parameters:
+	*   - `releaseId` - The id of the release to fetch documents for.
+	* @param options - Additional mutation options {@link BaseMutationOptions}.
+	* @returns A promise that resolves to the documents in the release.
+	*/
+	fetchDocuments({ releaseId }, options) {
+		return _getReleaseDocuments(this.#client, this.#httpRequest, releaseId, options);
+	}
+}, ObservableUsersClient = class {
+	#client;
+	#httpRequest;
+	constructor(client, httpRequest) {
+		this.#client = client, this.#httpRequest = httpRequest;
+	}
+	/**
+	* Fetch a user by user ID
+	*
+	* @param id - User ID of the user to fetch. If `me` is provided, a minimal response including the users role is returned.
+	*/
+	getById(id) {
+		return _requestObservable(this.#client, this.#httpRequest, { url: `/users/${id}` });
+	}
+}, UsersClient = class {
+	#client;
+	#httpRequest;
+	constructor(client, httpRequest) {
+		this.#client = client, this.#httpRequest = httpRequest;
+	}
+	/**
+	* Fetch a user by user ID
+	*
+	* @param id - User ID of the user to fetch. If `me` is provided, a minimal response including the users role is returned.
+	*/
+	getById(id) {
+		return _request(this.#client, this.#httpRequest, { url: `/users/${id}` });
+	}
+}, ObservableSanityClient = class ObservableSanityClient {
+	assets;
+	datasets;
+	live;
+	mediaLibrary;
+	projects;
+	users;
+	agent;
+	functions;
+	releases;
+	/**
+	* Private properties
+	*/
+	#clientConfig;
+	#httpRequest;
+	/**
+	* Instance properties
+	*/
+	listen = _listen;
+	constructor(httpRequest, config = defaultConfig) {
+		this.config(config), this.#httpRequest = httpRequest, this.assets = new ObservableAssetsClient(this, this.#httpRequest), this.datasets = new ObservableDatasetsClient(this, this.#httpRequest), this.live = new LiveClient(this), this.mediaLibrary = { video: new ObservableMediaLibraryVideoClient(this, this.#httpRequest) }, this.projects = new ObservableProjectsClient(this, this.#httpRequest), this.users = new ObservableUsersClient(this, this.#httpRequest), this.agent = { action: new ObservableAgentsActionClient(this, this.#httpRequest) }, this.functions = new ObservableFunctionsClient(this, this.#httpRequest), this.releases = new ObservableReleasesClient(this, this.#httpRequest);
+	}
+	/**
+	* Clone the client - returns a new instance
+	*/
+	clone() {
+		return new ObservableSanityClient(this.#httpRequest, this.config());
+	}
+	config(newConfig) {
+		if (newConfig === void 0) return { ...this.#clientConfig };
+		if (this.#clientConfig && this.#clientConfig.allowReconfigure === !1) throw Error("Existing client instance cannot be reconfigured - use `withConfig(newConfig)` to return a new client");
+		return this.#clientConfig = initConfig(newConfig, this.#clientConfig || {}), this;
+	}
+	/**
+	* Clone the client with a new (partial) configuration.
+	*
+	* @param newConfig - New client configuration properties, shallowly merged with existing configuration
+	*/
+	withConfig(newConfig) {
+		let thisConfig = this.config();
+		return new ObservableSanityClient(this.#httpRequest, {
+			...thisConfig,
+			...newConfig,
+			stega: {
+				...thisConfig.stega,
+				...typeof newConfig?.stega == "boolean" ? { enabled: newConfig.stega } : newConfig?.stega || {}
+			}
+		});
+	}
+	fetch(query, params, options) {
+		return _fetchObservable(this, this.#httpRequest, this.#clientConfig.stega, query, params, options);
+	}
+	getDocument(id, options) {
+		if (options?.includeAllVersions === !0) return _getDocumentObservable(this, this.#httpRequest, id, {
+			...options,
+			includeAllVersions: !0
+		});
+		let opts = {
+			signal: options?.signal,
+			tag: options?.tag,
+			releaseId: options?.releaseId,
+			...options && "includeAllVersions" in options ? { includeAllVersions: !1 } : {}
+		};
+		return _getDocumentObservable(this, this.#httpRequest, id, opts);
+	}
+	/**
+	* Fetch multiple documents in one request.
+	* Should be used sparingly - performing a query is usually a better option.
+	* The order/position of documents is preserved based on the original array of IDs.
+	* If any of the documents are missing, they will be replaced by a `null` entry in the returned array
+	*
+	* @param ids - Document IDs to fetch
+	* @param options - Request options
+	*/
+	getDocuments(ids, options) {
+		return _getDocumentsObservable(this, this.#httpRequest, ids, options);
+	}
+	/**
+	* Convenient and bandwidth efficient method of checking wether a set of document IDs exists.
+	* Returns a set of the IDs that exist.
+	*
+	* @param ids - Document IDs to check
+	* @param options - Request options
+	*/
+	documentsExists(ids, options) {
+		return _documentsExistsObservable(this, this.#httpRequest, ids, options);
+	}
+	create(document, options) {
+		return _createObservable(this, this.#httpRequest, document, "create", options);
+	}
+	createIfNotExists(document, options) {
+		return _createIfNotExistsObservable(this, this.#httpRequest, document, options);
+	}
+	createOrReplace(document, options) {
+		return _createOrReplaceObservable(this, this.#httpRequest, document, options);
+	}
+	createVersion({ document, publishedId, releaseId, baseId, ifBaseRevisionId }, options) {
+		if (!document) return _createVersionFromBaseObservable(this, this.#httpRequest, publishedId, baseId, releaseId, ifBaseRevisionId, options);
+		let documentVersionId = deriveDocumentVersionId("createVersion", {
+			document,
+			publishedId,
+			releaseId
+		}), documentVersion = {
+			...document,
+			_id: documentVersionId
+		}, versionPublishedId = publishedId || getPublishedId(document._id);
+		return _createVersionObservable(this, this.#httpRequest, documentVersion, versionPublishedId, options);
+	}
+	delete(selection, options) {
+		return _deleteObservable(this, this.#httpRequest, selection, options);
+	}
+	/**
+	* @public
+	*
+	* Deletes the draft or release version of a document.
+	*
+	* @remarks
+	* * Discarding a version with no `releaseId` will discard the draft version of the published document.
+	* * If the draft or release version does not exist, any error will throw.
+	*
+	* @param params - Version action parameters:
+	*   - `releaseId` - The ID of the release to discard the document from.
+	*   - `publishedId` - The published ID of the document to discard.
+	* @param purge - if `true` the document history is also discarded.
+	* @param options - Additional action options.
+	* @returns an observable that resolves to the `transactionId`.
+	*
+	* @example Discarding a release version of a document
+	* ```ts
+	* client.observable.discardVersion({publishedId: 'myDocument', releaseId: 'myRelease'})
+	* // The document with the ID `versions.myRelease.myDocument` will be discarded.
+	* ```
+	*
+	* @example Discarding a draft version of a document
+	* ```ts
+	* client.observable.discardVersion({publishedId: 'myDocument'})
+	* // The document with the ID `drafts.myDocument` will be discarded.
+	* ```
+	*/
+	discardVersion({ releaseId, publishedId }, purge, options) {
+		let documentVersionId = getDocumentVersionId(publishedId, releaseId);
+		return _discardVersionObservable(this, this.#httpRequest, documentVersionId, purge, options);
+	}
+	replaceVersion({ document, publishedId, releaseId }, options) {
+		let documentVersionId = deriveDocumentVersionId("replaceVersion", {
+			document,
+			publishedId,
+			releaseId
+		}), documentVersion = {
+			...document,
+			_id: documentVersionId
+		};
+		return _replaceVersionObservable(this, this.#httpRequest, documentVersion, options);
+	}
+	/**
+	* @public
+	*
+	* Used to indicate when a document within a release should be unpublished when
+	* the release is run.
+	*
+	* @remarks
+	* * If the published document does not exist, an error will be thrown.
+	*
+	* @param params - Version action parameters:
+	*   - `releaseId` - The ID of the release to unpublish the document from.
+	*   - `publishedId` - The published ID of the document to unpublish.
+	* @param options - Additional action options.
+	* @returns an observable that resolves to the `transactionId`.
+	*
+	* @example Unpublishing a release version of a published document
+	* ```ts
+	* client.observable.unpublishVersion({publishedId: 'myDocument', releaseId: 'myRelease'})
+	* // The document with the ID `versions.myRelease.myDocument` will be unpublished. when `myRelease` is run.
+	* ```
+	*/
+	unpublishVersion({ releaseId, publishedId }, options) {
+		let versionId = getVersionId(publishedId, releaseId);
+		return _unpublishVersionObservable(this, this.#httpRequest, versionId, publishedId, options);
+	}
+	mutate(operations, options) {
+		return _mutateObservable(this, this.#httpRequest, operations, options);
+	}
+	/**
+	* Create a new buildable patch of operations to perform
+	*
+	* @param selection - Document ID, an array of document IDs, or an object with `query` and optional `params`, defining which document(s) to patch
+	* @param operations - Optional object of patch operations to initialize the patch instance with
+	* @returns Patch instance - call `.commit()` to perform the operations defined
+	*/
+	patch(selection, operations) {
+		return new ObservablePatch(selection, operations, this);
+	}
+	/**
+	* Create a new transaction of mutations
+	*
+	* @param operations - Optional array of mutation operations to initialize the transaction instance with
+	*/
+	transaction(operations) {
+		return new ObservableTransaction(operations, this);
+	}
+	/**
+	* Perform action operations against the configured dataset
+	*
+	* @param operations - Action operation(s) to execute
+	* @param options - Action options
+	*/
+	action(operations, options) {
+		return _actionObservable(this, this.#httpRequest, operations, options);
+	}
+	/**
+	* Perform an HTTP request against the Sanity API
+	*
+	* @param options - Request options
+	*/
+	request(options) {
+		return _requestObservable(this, this.#httpRequest, options);
+	}
+	/**
+	* Get a Sanity API URL for the URI provided
+	*
+	* @param uri - URI/path to build URL for
+	* @param canUseCdn - Whether or not to allow using the API CDN for this route
+	*/
+	getUrl(uri, canUseCdn) {
+		return _getUrl(this, uri, canUseCdn);
+	}
+	/**
+	* Get a Sanity API URL for the data operation and path provided
+	*
+	* @param operation - Data operation (eg `query`, `mutate`, `listen` or similar)
+	* @param path - Path to append after the operation
+	*/
+	getDataUrl(operation, path) {
+		return _getDataUrl(this, operation, path);
+	}
+}, SanityClient = class SanityClient {
+	assets;
+	datasets;
+	live;
+	mediaLibrary;
+	projects;
+	users;
+	agent;
+	functions;
+	releases;
+	/**
+	* Observable version of the Sanity client, with the same configuration as the promise-based one
+	*/
+	observable;
+	/**
+	* Private properties
+	*/
+	#clientConfig;
+	#httpRequest;
+	/**
+	* Instance properties
+	*/
+	listen = _listen;
+	constructor(httpRequest, config = defaultConfig) {
+		this.config(config), this.#httpRequest = httpRequest, this.assets = new AssetsClient(this, this.#httpRequest), this.datasets = new DatasetsClient(this, this.#httpRequest), this.live = new LiveClient(this), this.mediaLibrary = { video: new MediaLibraryVideoClient(this, this.#httpRequest) }, this.projects = new ProjectsClient(this, this.#httpRequest), this.users = new UsersClient(this, this.#httpRequest), this.agent = { action: new AgentActionsClient(this, this.#httpRequest) }, this.functions = new FunctionsClient(this, this.#httpRequest), this.releases = new ReleasesClient(this, this.#httpRequest), this.observable = new ObservableSanityClient(httpRequest, config);
+	}
+	/**
+	* Clone the client - returns a new instance
+	*/
+	clone() {
+		return new SanityClient(this.#httpRequest, this.config());
+	}
+	config(newConfig) {
+		if (newConfig === void 0) return { ...this.#clientConfig };
+		if (this.#clientConfig && this.#clientConfig.allowReconfigure === !1) throw Error("Existing client instance cannot be reconfigured - use `withConfig(newConfig)` to return a new client");
+		return this.observable && this.observable.config(newConfig), this.#clientConfig = initConfig(newConfig, this.#clientConfig || {}), this;
+	}
+	/**
+	* Clone the client with a new (partial) configuration.
+	*
+	* @param newConfig - New client configuration properties, shallowly merged with existing configuration
+	*/
+	withConfig(newConfig) {
+		let thisConfig = this.config();
+		return new SanityClient(this.#httpRequest, {
+			...thisConfig,
+			...newConfig,
+			stega: {
+				...thisConfig.stega,
+				...typeof newConfig?.stega == "boolean" ? { enabled: newConfig.stega } : newConfig?.stega || {}
+			}
+		});
+	}
+	fetch(query, params, options) {
+		return _fetch(this, this.#httpRequest, this.#clientConfig.stega, query, params, options);
+	}
+	getDocument(id, options) {
+		if (options?.includeAllVersions === !0) return _getDocument(this, this.#httpRequest, id, {
+			...options,
+			includeAllVersions: !0
+		});
+		let opts = {
+			signal: options?.signal,
+			tag: options?.tag,
+			releaseId: options?.releaseId,
+			...options && "includeAllVersions" in options ? { includeAllVersions: !1 } : {}
+		};
+		return _getDocument(this, this.#httpRequest, id, opts);
+	}
+	/**
+	* Fetch multiple documents in one request.
+	* Should be used sparingly - performing a query is usually a better option.
+	* The order/position of documents is preserved based on the original array of IDs.
+	* If any of the documents are missing, they will be replaced by a `null` entry in the returned array
+	*
+	* @param ids - Document IDs to fetch
+	* @param options - Request options
+	*/
+	getDocuments(ids, options) {
+		return _getDocuments(this, this.#httpRequest, ids, options);
+	}
+	/**
+	* Convenient and bandwidth efficient method of checking wether a set of document IDs exists.
+	* Returns a set of the IDs that exist.
+	*
+	* @param ids - Document IDs to check
+	* @param options - Request options
+	*/
+	documentsExists(ids, options) {
+		return _documentsExists(this, this.#httpRequest, ids, options);
+	}
+	create(document, options) {
+		return _create(this, this.#httpRequest, document, "create", options);
+	}
+	createIfNotExists(document, options) {
+		return _createIfNotExists(this, this.#httpRequest, document, options);
+	}
+	createOrReplace(document, options) {
+		return _createOrReplace(this, this.#httpRequest, document, options);
+	}
+	createVersion({ document, publishedId, releaseId, baseId, ifBaseRevisionId }, options) {
+		if (!document) return _createVersionFromBase(this, this.#httpRequest, publishedId, baseId, releaseId, ifBaseRevisionId, options);
+		let documentVersionId = deriveDocumentVersionId("createVersion", {
+			document,
+			publishedId,
+			releaseId
+		}), documentVersion = {
+			...document,
+			_id: documentVersionId
+		}, versionPublishedId = publishedId || getPublishedId(document._id);
+		return _createVersion(this, this.#httpRequest, documentVersion, versionPublishedId, options);
+	}
+	delete(selection, options) {
+		return _delete(this, this.#httpRequest, selection, options);
+	}
+	/**
+	* @public
+	*
+	* Deletes the draft or release version of a document.
+	*
+	* @remarks
+	* * Discarding a version with no `releaseId` will discard the draft version of the published document.
+	* * If the draft or release version does not exist, any error will throw.
+	*
+	* @param params - Version action parameters:
+	*   - `releaseId` - The ID of the release to discard the document from.
+	*   - `publishedId` - The published ID of the document to discard.
+	* @param purge - if `true` the document history is also discarded.
+	* @param options - Additional action options.
+	* @returns a promise that resolves to the `transactionId`.
+	*
+	* @example Discarding a release version of a document
+	* ```ts
+	* client.discardVersion({publishedId: 'myDocument', releaseId: 'myRelease'})
+	* // The document with the ID `versions.myRelease.myDocument` will be discarded.
+	* ```
+	*
+	* @example Discarding a draft version of a document
+	* ```ts
+	* client.discardVersion({publishedId: 'myDocument'})
+	* // The document with the ID `drafts.myDocument` will be discarded.
+	* ```
+	*/
+	discardVersion({ releaseId, publishedId }, purge, options) {
+		let documentVersionId = getDocumentVersionId(publishedId, releaseId);
+		return _discardVersion(this, this.#httpRequest, documentVersionId, purge, options);
+	}
+	replaceVersion({ document, publishedId, releaseId }, options) {
+		let documentVersionId = deriveDocumentVersionId("replaceVersion", {
+			document,
+			publishedId,
+			releaseId
+		}), documentVersion = {
+			...document,
+			_id: documentVersionId
+		};
+		return _replaceVersion(this, this.#httpRequest, documentVersion, options);
+	}
+	/**
+	* @public
+	*
+	* Used to indicate when a document within a release should be unpublished when
+	* the release is run.
+	*
+	* @remarks
+	* * If the published document does not exist, an error will be thrown.
+	*
+	* @param params - Version action parameters:
+	*   - `releaseId` - The ID of the release to unpublish the document from.
+	*   - `publishedId` - The published ID of the document to unpublish.
+	* @param options - Additional action options.
+	* @returns a promise that resolves to the `transactionId`.
+	*
+	* @example Unpublishing a release version of a published document
+	* ```ts
+	* await client.unpublishVersion({publishedId: 'myDocument', releaseId: 'myRelease'})
+	* // The document with the ID `versions.myRelease.myDocument` will be unpublished. when `myRelease` is run.
+	* ```
+	*/
+	unpublishVersion({ releaseId, publishedId }, options) {
+		let versionId = getVersionId(publishedId, releaseId);
+		return _unpublishVersion(this, this.#httpRequest, versionId, publishedId, options);
+	}
+	mutate(operations, options) {
+		return _mutate(this, this.#httpRequest, operations, options);
+	}
+	/**
+	* Create a new buildable patch of operations to perform
+	*
+	* @param selection - Document ID, an array of document IDs, or an object with `query` and optional `params`, defining which document(s) to patch
+	* @param operations - Optional object of patch operations to initialize the patch instance with
+	* @returns Patch instance - call `.commit()` to perform the operations defined
+	*/
+	patch(documentId, operations) {
+		return new Patch(documentId, operations, this);
+	}
+	/**
+	* Create a new transaction of mutations
+	*
+	* @param operations - Optional array of mutation operations to initialize the transaction instance with
+	*/
+	transaction(operations) {
+		return new Transaction(operations, this);
+	}
+	/**
+	* Perform action operations against the configured dataset
+	* Returns a promise that resolves to the transaction result
+	*
+	* @param operations - Action operation(s) to execute
+	* @param options - Action options
+	*/
+	action(operations, options) {
+		return _action(this, this.#httpRequest, operations, options);
+	}
+	/**
+	* Perform a request against the Sanity API
+	* NOTE: Only use this for Sanity API endpoints, not for your own APIs!
+	*
+	* @param options - Request options
+	* @returns Promise resolving to the response body
+	*/
+	request(options) {
+		return _request(this, this.#httpRequest, options);
+	}
+	/**
+	* Perform an HTTP request a `/data` sub-endpoint
+	* NOTE: Considered internal, thus marked as deprecated. Use `request` instead.
+	*
+	* @deprecated - Use `request()` or your own HTTP library instead
+	* @param endpoint - Endpoint to hit (mutate, query etc)
+	* @param body - Request body
+	* @param options - Request options
+	* @internal
+	*/
+	dataRequest(endpoint, body, options) {
+		return _dataRequest(this, this.#httpRequest, endpoint, body, options);
+	}
+	/**
+	* Get a Sanity API URL for the URI provided
+	*
+	* @param uri - URI/path to build URL for
+	* @param canUseCdn - Whether or not to allow using the API CDN for this route
+	*/
+	getUrl(uri, canUseCdn) {
+		return _getUrl(this, uri, canUseCdn);
+	}
+	/**
+	* Get a Sanity API URL for the data operation and path provided
+	*
+	* @param operation - Data operation (eg `query`, `mutate`, `listen` or similar)
+	* @param path - Path to append after the operation
+	*/
+	getDataUrl(operation, path) {
+		return _getDataUrl(this, operation, path);
+	}
+};
+/**
+* Create the `requester` and `createClient` exports, that have environment specific middleware for node and browsers
+* @internal
+*/
+function defineCreateClientExports(envOptions, ClassConstructor) {
+	let defaultRequester = defineRequester(envOptions).observable, createClient = (config) => {
+		let { observable: clientRequester, promise: clientRequesterPromise } = defineRequester(envOptions, {
+			ignoreWarnings: config.ignoreWarnings,
+			maxRetries: config.maxRetries,
+			retryDelay: config.retryDelay
+		}), performRequest = async (options) => (await clientRequesterPromise({
+			redirect: "manual",
+			...options
+		})).body, httpRequest = (options, requestHandler) => requestHandler ? requestHandler(options, performRequest) : performRequest(options);
+		return new ClassConstructor(httpRequest, {
+			...config,
+			requester: clientRequester,
+			resolveFetch: config.resolveFetch ?? envOptions.resolveFetch
+		});
+	};
+	return {
+		requester: defaultRequester,
+		createClient
+	};
+}
+function defineDeprecatedCreateClient(createClient) {
+	return function deprecatedCreateClient(config) {
+		return printNoDefaultExport(), createClient(config);
+	};
+}
+var name = "@sanity/client", version = "8.1.0";
+const log = createDebug("sanity:client");
+function isNodeReadableStream(value) {
+	return typeof value != "object" || !value || !("pipe" in value) ? !1 : typeof value.pipe == "function";
+}
+const proxyFetchCache = /* @__PURE__ */ new Map();
+function getProxyFetch(proxyUrl) {
+	let cached = proxyFetchCache.get(proxyUrl);
+	if (cached) return cached;
+	let fetch = createNodeFetch({
+		proxy: proxyUrl,
+		connections: 30
+	});
+	return proxyFetchCache.set(proxyUrl, fetch), fetch;
+}
+let envDefaultFetch;
+/**
+* Exposed via `EnvironmentOptions.resolveFetch` so EventSource connections
+* use the same transport as regular requests instead of falling back to
+* `globalThis.fetch`. Everything get-it's Node fetch provides then applies
+* to SSE too: the undici dispatcher configuration, an explicit `proxy`
+* config (pass the URL), and env-proxy support
+* (`HTTP_PROXY`/`HTTPS_PROXY`/`NO_PROXY`, which Node's own global fetch does
+* not read — that is opt-in via `NODE_USE_ENV_PROXY`, and not on our 22.12
+* floor). Reached via the env rather than a direct import so `get-it/node`
+* (and with it `undici`) stays out of the browser bundle.
+*
+* @internal
+*/
+function resolveFetch(proxyUrl) {
+	return typeof proxyUrl == "string" ? getProxyFetch(proxyUrl) : (envDefaultFetch ??= createNodeFetch(), envDefaultFetch);
+}
+const middleware = [
+	debug({
+		log: (message, ...args) => log(message, ...args),
+		verbose: !0
+	}),
+	{ beforeRequest(opts) {
+		let configLineage = typeof opts.meta?.lineage == "string" ? opts.meta.lineage : void 0, lineage = typeof process < "u" && process.env.X_SANITY_LINEAGE || configLineage;
+		if (!lineage) return opts;
+		let headers = new Headers(opts.headers);
+		return headers.set("x-sanity-lineage", lineage), {
+			...opts,
+			headers
+		};
+	} },
+	{ beforeRequest(opts) {
+		return isNodeReadableStream(opts.body) ? {
+			...opts,
+			body: Readable.toWeb(opts.body)
+		} : opts;
+	} }
+], exp = defineCreateClientExports({
+	headers: { "User-Agent": `${name} ${version}` },
+	middleware,
+	resolveFetch
+}, SanityClient), requester = exp.requester, createClient = exp.createClient, deprecatedCreateClient = defineDeprecatedCreateClient(createClient);
+export { BasePatch, BaseTransaction, ChannelError, ClientError, ConnectionFailedError, CorsOriginError, DisconnectError, EXPERIMENTAL_API_WARNING, MessageError, MessageParseError, ObservablePatch, ObservableSanityClient, ObservableTransaction, Patch, SanityClient, ServerError, Transaction, connectEventSource, createClient, deprecatedCreateClient as default, formatQueryParseError, isHttpError, isQueryParseError, isTimeoutError, requester, validateApiPerspective };
+
+//# sourceMappingURL=index.node.js.map