azure-mock 4.2.0 → 4.3.3

package/dist/index.js

@@ -0,0 +1,1265 @@
+import { ID_SEPARATOR, InvalidOperationError, Operation, checkIsDeepEqual, chunk, exhaustiveGuard, getDecodedUriComponent, getOrCreate, getResult, html, noop, streamToText, takeOne } from "@esposter/shared";
+import { toHttpHeadersLike } from "@azure/core-http-compat";
+import { RestError, createHttpHeaders, createPipelineRequest } from "@azure/core-rest-pipeline";
+import { AnonymousCredential } from "@azure/storage-blob";
+import { Readable } from "node:stream";
+import { AZURE_MAX_PAGE_SIZE, AZURE_MAX_QUEUE_VISIBILITY_TIMEOUT_MS, BinaryOperator, deserializeClause, deserializeKey, getTableNullClause, serializeClauses } from "@esposter/azure";
+// src/constants.ts
+const BLOB_NOT_FOUND_ERROR_CODE = "BlobNotFound";
+const BLOB_NOT_FOUND_MESSAGE = "The specified blob does not exist.";
+const CONDITION_NOT_MET_ERROR_CODE = "ConditionNotMet";
+const CONDITION_NOT_MET_MESSAGE = "The condition specified using HTTP conditional header(s) is not met.";
+const MOCK_BLOB_BASE_URL = "https://mockaccount.blob.core.windows.net";
+const MOCK_QUEUE_BASE_URL = "https://mockaccount.queue.core.windows.net";
+const MOCK_SEARCH_BASE_URL = "https://mockaccount.search.windows.net";
+const MOCK_TABLE_BASE_URL = "https://mockaccount.table.core.windows.net";
+// src/models/shared/NotImplementedError.ts
+var NotImplementedError = class extends Error {
+	constructor(name) {
+		super(`${name} is not implemented in the mock`);
+		this.name = "NotImplementedError";
+	}
+};
+// src/services/container/getMockBlobKey.ts
+const getMockBlobKey = (containerName, blobName) => `${encodeURIComponent(containerName)}${ID_SEPARATOR}${encodeURIComponent(blobName)}`;
+// src/store/MockContainerBlobDatesDatabase.ts
+const MockContainerBlobDatesDatabase = /* @__PURE__ */ new Map();
+// src/store/MockContainerBlobMetadataDatabase.ts
+const MockContainerBlobMetadataDatabase = /* @__PURE__ */ new Map();
+// src/store/MockContainerDatabase.ts
+var MockContainerDatabaseMap = class extends Map {
+	clear() {
+		super.clear();
+		MockContainerBlobDatesDatabase.clear();
+		MockContainerBlobMetadataDatabase.clear();
+	}
+};
+const MockContainerDatabase = new MockContainerDatabaseMap();
+// src/services/container/getMockContainer.ts
+const getMockContainer = (containerName) => getOrCreate(MockContainerDatabase, containerName, () => /* @__PURE__ */ new Map());
+// src/services/container/storeMockBlobMetadata.ts
+const storeMockBlobMetadata = (containerName, blobName, metadata) => {
+	const key = getMockBlobKey(containerName, blobName);
+	if (metadata) MockContainerBlobMetadataDatabase.set(key, metadata);
+	else MockContainerBlobMetadataDatabase.delete(key);
+};
+// src/services/container/deleteMockBlob.ts
+const deleteMockBlob = (containerName, blobName) => {
+	if (!getMockContainer(containerName).delete(blobName)) return false;
+	MockContainerBlobDatesDatabase.delete(getMockBlobKey(containerName, blobName));
+	storeMockBlobMetadata(containerName, blobName, void 0);
+	return true;
+};
+// src/services/container/getAzureErrorXml.ts
+/**
+* Generates a standard Azure Storage error XML response body.
+* @param errorCode The official Azure error code (e.g., "BlobNotFound").
+* @param errorMessage The user-friendly error message.
+* @returns A formatted XML string.
+*/
+const getAzureErrorXml = (errorCode, errorMessage) => html`<?xml version="1.0" encoding="utf-8"?>
+    <Error>
+      <code>${errorCode}</code>
+      <Message>${errorMessage}</Message>
+    </Error>`;
+// src/services/container/getBlobUrlParts.ts
+const decodeSegment = (segment) => getDecodedUriComponent(segment, segment);
+const getBlobUrlParts = (url) => {
+	const parsedUrl = getResult(() => new URL(url)).unwrapOr(void 0);
+	if (!parsedUrl) return void 0;
+	const pathSegments = parsedUrl.pathname.split("/").filter(Boolean);
+	if (pathSegments.length < 2) return void 0;
+	return {
+		blobName: decodeSegment(pathSegments.slice(1).join("/")),
+		containerName: decodeSegment(takeOne(pathSegments))
+	};
+};
+// src/services/container/constants.ts
+const MOCK_BLOB_SEEDED_DATE = /* @__PURE__ */ new Date(-864e13);
+const MOCK_BLOB_SEEDED_PROPERTIES = {
+	createdOn: MOCK_BLOB_SEEDED_DATE,
+	etag: "\"seeded\"",
+	lastModified: MOCK_BLOB_SEEDED_DATE
+};
+// src/services/container/readMockBlobDates.ts
+const readMockBlobDates = (containerName, blobName) => MockContainerBlobDatesDatabase.get(getMockBlobKey(containerName, blobName)) ?? MOCK_BLOB_SEEDED_PROPERTIES;
+// src/services/container/toWebResourceLike.ts
+const toWebResourceLike = (request) => ({
+	abortSignal: request.abortSignal,
+	agent: request.agent,
+	body: request.body,
+	clone: () => {
+		throw new NotImplementedError(`${toWebResourceLike.name}(…).clone`);
+	},
+	formData: request.formData,
+	headers: toHttpHeadersLike(request.headers),
+	keepAlive: request.disableKeepAlive,
+	method: request.method,
+	onDownloadProgress: request.onDownloadProgress,
+	onUploadProgress: request.onUploadProgress,
+	prepare: () => {
+		throw new NotImplementedError(`${toWebResourceLike.name}(…).prepare`);
+	},
+	proxySettings: request.proxySettings,
+	requestId: request.headers.get("x-ms-client-request-id") ?? request.requestId,
+	requestOverrides: request.requestOverrides,
+	streamResponseStatusCodes: request.streamResponseStatusCodes,
+	timeout: request.timeout,
+	url: request.url,
+	validateRequestProperties: noop,
+	withCredentials: request.withCredentials
+});
+// src/services/shared/createMockResponse.ts
+const createMockResponse = (status, url = "") => ({
+	headers: toHttpHeadersLike(createHttpHeaders()),
+	parsedHeaders: {},
+	request: toWebResourceLike(createPipelineRequest({ url })),
+	status
+});
+// src/models/container/MockBlobBatchClient.ts
+var MockBlobBatchClient = class {
+	url;
+	constructor(url) {
+		this.url = url;
+	}
+	/**
+	* Simulates the deletion of multiple blobs in a single batch request.
+	* It iterates through the requested deletions, removes existing blobs from the
+	* underlying MockContainerDatabase, and builds a response object that reports
+	* which deletions succeeded and which failed (e.g. for blobs that didn't exist).
+	*/
+	deleteBlobs(urls, credential, options) {
+		const { ifUnmodifiedSince, ...unsupportedConditions } = options?.conditions ?? {};
+		const unsupportedConditionName = Object.entries(unsupportedConditions).find(([, value]) => value !== void 0)?.[0];
+		if (unsupportedConditionName !== void 0) return Promise.reject(new NotImplementedError(`deleteBlobs with ${unsupportedConditionName}`));
+		const subResponses = [];
+		let subResponsesSucceededCount = 0;
+		let subResponsesFailedCount = 0;
+		for (const url of urls) {
+			const urlParts = getBlobUrlParts(url);
+			if (!urlParts) {
+				subResponses.push(this.#createFailedSubResponse(credential, 400, "InvalidUri", "Invalid blob URL format."));
+				subResponsesFailedCount++;
+				continue;
+			}
+			const { blobName, containerName } = urlParts;
+			if (this.#checkIsModifiedSince(containerName, blobName, ifUnmodifiedSince)) {
+				subResponses.push(this.#createFailedSubResponse(credential, 412, CONDITION_NOT_MET_ERROR_CODE, CONDITION_NOT_MET_MESSAGE));
+				subResponsesFailedCount++;
+				continue;
+			}
+			if (deleteMockBlob(containerName, blobName)) {
+				subResponses.push({
+					_request: {
+						credential,
+						url: this.url
+					},
+					headers: toHttpHeadersLike(createHttpHeaders()),
+					status: 202,
+					statusMessage: "Accepted"
+				});
+				subResponsesSucceededCount++;
+			} else {
+				subResponses.push(this.#createFailedSubResponse(credential, 404, BLOB_NOT_FOUND_ERROR_CODE, BLOB_NOT_FOUND_MESSAGE));
+				subResponsesFailedCount++;
+			}
+		}
+		return Promise.resolve({
+			_response: {
+				...createMockResponse(202, this.url),
+				headers: toHttpHeadersLike(createHttpHeaders({
+					"content-type": "multipart/mixed",
+					"x-ms-request-id": crypto.randomUUID()
+				}))
+			},
+			subResponses,
+			subResponsesFailedCount,
+			subResponsesSucceededCount
+		});
+	}
+	getContainer(containerName) {
+		return getMockContainer(containerName);
+	}
+	#checkIsModifiedSince(containerName, blobName, ifUnmodifiedSince) {
+		return ifUnmodifiedSince !== void 0 && getMockContainer(containerName).has(blobName) && readMockBlobDates(containerName, blobName).lastModified > ifUnmodifiedSince;
+	}
+	#createFailedSubResponse(credential, status, errorCode, statusMessage) {
+		return {
+			_request: {
+				credential,
+				url: this.url
+			},
+			bodyAsText: getAzureErrorXml(errorCode, statusMessage),
+			errorCode,
+			headers: toHttpHeadersLike(createHttpHeaders()),
+			status,
+			statusMessage
+		};
+	}
+};
+// src/models/shared/MockRestError.ts
+var MockRestError = class extends RestError {
+	constructor(message, statusCode) {
+		super(message, { statusCode });
+		this.name = "MockRestError";
+	}
+};
+// src/services/container/getBlobUrl.ts
+const getBlobUrl = (containerName, blobName) => `${MOCK_BLOB_BASE_URL}/${containerName}/${blobName.split("/").map((segment) => encodeURIComponent(segment)).join("/")}`;
+// src/services/container/storeMockBlobWrite.ts
+const storeMockBlobWrite = (containerName, blobName, isExisting) => {
+	const key = getMockBlobKey(containerName, blobName);
+	const lastModified = /* @__PURE__ */ new Date();
+	MockContainerBlobDatesDatabase.set(key, {
+		createdOn: MockContainerBlobDatesDatabase.get(key)?.createdOn ?? (isExisting ? MOCK_BLOB_SEEDED_DATE : lastModified),
+		etag: `"${crypto.randomUUID()}"`,
+		lastModified
+	});
+};
+// src/services/shared/getMockSasUrl.ts
+const getMockSasUrl = (url, permissions, resourceType) => `${url}?sv=2025-11-05&${resourceType ? `sr=${resourceType}&` : ""}sig=mock-signature&st=1970-01-01T00:00:00Z&se=2099-12-31T23:59:59Z&sp=${permissions?.toString() ?? "r"}`;
+// src/models/container/MockBlobClient.ts
+var MockBlobClient = class {
+	connectionString;
+	containerName;
+	credential = new AnonymousCredential();
+	name;
+	url;
+	get container() {
+		return getMockContainer(this.containerName);
+	}
+	constructor(connectionString, containerName, blobName) {
+		this.connectionString = connectionString;
+		this.containerName = containerName;
+		this.name = blobName;
+		this.url = getBlobUrl(this.containerName, this.name);
+	}
+	abortCopyFromURL() {
+		throw new NotImplementedError(this.abortCopyFromURL.name);
+	}
+	beginCopyFromURL(copySource) {
+		const sourceParts = getBlobUrlParts(copySource);
+		if (!sourceParts) throw new MockRestError("Invalid copy source URL format", 400);
+		const { blobName: sourceBlobName, containerName: sourceContainerName } = sourceParts;
+		const sourceContainer = MockContainerDatabase.get(sourceContainerName);
+		if (!sourceContainer) throw new MockRestError("Source container not found", 404);
+		const sourceData = sourceContainer.get(sourceBlobName);
+		if (!sourceData) throw new MockRestError("Source blob not found", 404);
+		storeMockBlobWrite(this.containerName, this.name, this.container.has(this.name));
+		this.container.set(this.name, Buffer.from(sourceData));
+		const response = { _response: createMockResponse(202, `${this.url}?comp=copy`) };
+		return Promise.resolve({
+			cancelOperation: () => Promise.resolve(),
+			getOperationState: () => ({
+				isCompleted: true,
+				result: response
+			}),
+			getResult: () => response,
+			isDone: () => true,
+			isStopped: () => false,
+			onProgress: () => noop,
+			poll: () => Promise.resolve(),
+			pollUntilDone: () => Promise.resolve(response),
+			stopPolling: noop
+		});
+	}
+	createSnapshot() {
+		throw new NotImplementedError(this.createSnapshot.name);
+	}
+	delete() {
+		if (!deleteMockBlob(this.containerName, this.name)) throw new MockRestError(BLOB_NOT_FOUND_MESSAGE, 404);
+		return Promise.resolve({ _response: createMockResponse(200) });
+	}
+	deleteIfExists() {
+		const succeeded = deleteMockBlob(this.containerName, this.name);
+		return Promise.resolve({
+			_response: createMockResponse(succeeded ? 200 : 404),
+			succeeded
+		});
+	}
+	deleteImmutabilityPolicy() {
+		throw new NotImplementedError(this.deleteImmutabilityPolicy.name);
+	}
+	download() {
+		const buffer = this.container.get(this.name);
+		if (!buffer) throw new MockRestError(BLOB_NOT_FOUND_MESSAGE, 404);
+		return Promise.resolve({
+			_response: createMockResponse(200),
+			etag: readMockBlobDates(this.containerName, this.name).etag,
+			readableStreamBody: Readable.from(buffer)
+		});
+	}
+	downloadToBuffer() {
+		const data = this.container.get(this.name);
+		if (!data) throw new MockRestError(BLOB_NOT_FOUND_MESSAGE, 404);
+		return Promise.resolve(Buffer.from(data));
+	}
+	downloadToFile() {
+		throw new NotImplementedError(this.downloadToFile.name);
+	}
+	exists() {
+		return Promise.resolve(this.container.has(this.name));
+	}
+	generateSasStringToSign() {
+		throw new NotImplementedError(this.generateSasStringToSign.name);
+	}
+	generateSasUrl(options) {
+		return Promise.resolve(getMockSasUrl(this.url, options.permissions, "b"));
+	}
+	generateUserDelegationSasStringToSign() {
+		throw new NotImplementedError(this.generateUserDelegationSasStringToSign.name);
+	}
+	generateUserDelegationSasUrl() {
+		throw new NotImplementedError(this.generateUserDelegationSasUrl.name);
+	}
+	getAccountInfo() {
+		throw new NotImplementedError(this.getAccountInfo.name);
+	}
+	getAppendBlobClient() {
+		throw new NotImplementedError(this.getAppendBlobClient.name);
+	}
+	getBlobLeaseClient() {
+		throw new NotImplementedError(this.getBlobLeaseClient.name);
+	}
+	getBlockBlobClient() {
+		throw new NotImplementedError(this.getBlockBlobClient.name);
+	}
+	getPageBlobClient() {
+		throw new NotImplementedError(this.getPageBlobClient.name);
+	}
+	getProperties() {
+		const blob = this.container.get(this.name);
+		if (!blob) throw new MockRestError(BLOB_NOT_FOUND_MESSAGE, 404);
+		return Promise.resolve({
+			_response: createMockResponse(200),
+			contentLength: blob.byteLength,
+			...readMockBlobDates(this.containerName, this.name)
+		});
+	}
+	getTags() {
+		throw new NotImplementedError(this.getTags.name);
+	}
+	setAccessTier() {
+		throw new NotImplementedError(this.setAccessTier.name);
+	}
+	setHTTPHeaders() {
+		throw new NotImplementedError(this.setHTTPHeaders.name);
+	}
+	setImmutabilityPolicy() {
+		throw new NotImplementedError(this.setImmutabilityPolicy.name);
+	}
+	setLegalHold() {
+		throw new NotImplementedError(this.setLegalHold.name);
+	}
+	setMetadata(metadata) {
+		if (!this.container.has(this.name)) throw new MockRestError(BLOB_NOT_FOUND_MESSAGE, 404);
+		MockContainerBlobMetadataDatabase.set(getMockBlobKey(this.containerName, this.name), metadata ?? {});
+		storeMockBlobWrite(this.containerName, this.name, true);
+		return Promise.resolve({
+			_response: createMockResponse(200),
+			...readMockBlobDates(this.containerName, this.name)
+		});
+	}
+	setTags() {
+		throw new NotImplementedError(this.setTags.name);
+	}
+	syncCopyFromURL() {
+		throw new NotImplementedError(this.syncCopyFromURL.name);
+	}
+	undelete() {
+		throw new NotImplementedError(this.undelete.name);
+	}
+	withSnapshot() {
+		throw new NotImplementedError(this.withSnapshot.name);
+	}
+	withVersion() {
+		throw new NotImplementedError(this.withVersion.name);
+	}
+};
+// src/services/container/checkIsReadableStream.ts
+const checkIsReadableStream = (value) => value instanceof Readable;
+// src/services/container/bodyToBuffer.ts
+const bodyToBuffer = async (body) => {
+	if (body === null) return Buffer.alloc(0);
+	else if (typeof body === "string") return Buffer.from(body);
+	else if (body instanceof ArrayBuffer) return Buffer.from(body);
+	else if (ArrayBuffer.isView(body)) return Buffer.from(body.buffer, body.byteOffset, body.byteLength);
+	else if (typeof body === "function") {
+		const streamOrBlob = body();
+		return bodyToBuffer(streamOrBlob);
+	} else if (body instanceof Blob) {
+		const arrayBuffer = await body.arrayBuffer();
+		return Buffer.from(arrayBuffer);
+	} else if (checkIsReadableStream(body)) return Buffer.from(await streamToText(body));
+	else if (body instanceof ReadableStream) {
+		const reader = body.getReader();
+		const chunks = [];
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			else chunks.push(value);
+		}
+		return Buffer.concat(chunks);
+	} else if (body instanceof FormData) throw new NotImplementedError(`${bodyToBuffer.name}(FormData)`);
+	else {
+		exhaustiveGuard(body);
+		return Buffer.alloc(0);
+	}
+};
+// src/models/container/MockBlockBlobClient.ts
+var MockBlockBlobClient = class extends MockBlobClient {
+	commitBlockList() {
+		throw new NotImplementedError(this.commitBlockList.name);
+	}
+	getBlockList() {
+		throw new NotImplementedError(this.getBlockList.name);
+	}
+	query() {
+		throw new NotImplementedError(this.query.name);
+	}
+	stageBlock() {
+		throw new NotImplementedError(this.stageBlock.name);
+	}
+	stageBlockFromURL() {
+		throw new NotImplementedError(this.stageBlockFromURL.name);
+	}
+	syncUploadFromURL() {
+		throw new NotImplementedError(this.syncUploadFromURL.name);
+	}
+	async upload(body, _contentLength, options) {
+		const buffer = await bodyToBuffer(body);
+		if (options?.conditions?.ifNoneMatch === "*" && this.container.has(this.name)) throw new MockRestError("The specified blob already exists.", 409);
+		if (options?.conditions?.ifMatch !== void 0 && options.conditions.ifMatch !== (this.container.has(this.name) ? readMockBlobDates(this.containerName, this.name).etag : void 0)) throw new MockRestError("The condition specified using HTTP conditional header(s) is not met.", 412);
+		storeMockBlobWrite(this.containerName, this.name, this.container.has(this.name));
+		storeMockBlobMetadata(this.containerName, this.name, options?.metadata);
+		this.container.set(this.name, buffer);
+		const { etag } = readMockBlobDates(this.containerName, this.name);
+		return {
+			_response: createMockResponse(201),
+			etag
+		};
+	}
+	uploadBrowserData() {
+		throw new NotImplementedError(this.uploadBrowserData.name);
+	}
+	uploadData() {
+		throw new NotImplementedError(this.uploadData.name);
+	}
+	uploadFile() {
+		throw new NotImplementedError(this.uploadFile.name);
+	}
+	uploadStream() {
+		throw new NotImplementedError(this.uploadStream.name);
+	}
+};
+// src/services/container/getBlobItemXml.ts
+const getBlobItemXml = ({ name, properties }) => html`<Blob>
+    <Name>${name}</Name>
+    <Properties>
+      <Last-Modified>${properties.lastModified.toUTCString()}</Last-Modified>
+      <Etag>${properties.etag}</Etag>
+      <Content-Length>${properties.contentLength}</Content-Length>
+      <Content-Type>${properties.contentType}</Content-Type>
+      <BlobType>BlockBlob</BlobType>
+      <LeaseStatus>unlocked</LeaseStatus>
+      <LeaseState>available</LeaseState>
+    </Properties>
+  </Blob>`;
+// src/services/container/getBlobPrefixXml.ts
+const getBlobPrefixXml = (name) => html`<BlobPrefix><Name>${name}</Name></BlobPrefix>`;
+// src/services/container/getListBlobsXml.ts
+/**
+* Generates a standard Azure Storage list blobs XML response body.
+* @param containerName The container name.
+* @param blobsXml The blobs xml data.
+* @returns A formatted XML string.
+*/
+const getListBlobsXml = (containerName, blobsXml) => html`<?xml version="1.0" encoding="utf8"?>
+    <EnumerationResults ServiceEndpoint="" ContainerName="${containerName}">
+      <Blobs>${blobsXml}</Blobs>
+      <NextMarker />
+    </EnumerationResults>`;
+// src/services/container/getListBlobsSegmentResponse.ts
+const getListBlobsSegmentResponse = (containerName, prefix, segment, blobsXml) => {
+	const segmentResponse = {
+		containerName,
+		marker: "",
+		prefix,
+		segment,
+		serviceEndpoint: ""
+	};
+	return {
+		_response: {
+			...createMockResponse(200),
+			bodyAsText: getListBlobsXml(containerName, blobsXml),
+			parsedBody: segmentResponse
+		},
+		...segmentResponse
+	};
+};
+// src/services/container/readMockBlobMetadata.ts
+const readMockBlobMetadata = (containerName, blobName) => MockContainerBlobMetadataDatabase.get(getMockBlobKey(containerName, blobName));
+// src/models/container/MockContainerClient.ts
+/**
+* An in-memory mock of the Azure ContainerClient — no emulator and no network.
+*
+* @example
+* const mockContainerClient = new MockContainerClient("", "hello world");
+* const blockBlobClient = mockContainerClient.getBlockBlobClient("hello world.txt");
+* await blockBlobClient.upload("hello world", 11);
+* const content = await blockBlobClient.downloadToBuffer();
+*/
+var MockContainerClient = class {
+	connectionString;
+	containerName;
+	credential = new AnonymousCredential();
+	url;
+	get container() {
+		return getMockContainer(this.containerName);
+	}
+	constructor(connectionString, containerName) {
+		this.connectionString = connectionString;
+		this.containerName = containerName;
+		this.url = `${MOCK_BLOB_BASE_URL}/${this.containerName}`;
+	}
+	create() {
+		throw new NotImplementedError(this.create.name);
+	}
+	createIfNotExists() {
+		throw new NotImplementedError(this.createIfNotExists.name);
+	}
+	delete() {
+		throw new NotImplementedError(this.delete.name);
+	}
+	deleteBlob(blobName) {
+		if (!deleteMockBlob(this.containerName, blobName)) throw new MockRestError(BLOB_NOT_FOUND_MESSAGE, 404);
+		return Promise.resolve({ _response: createMockResponse(200, getBlobUrl(this.containerName, blobName)) });
+	}
+	deleteIfExists() {
+		throw new NotImplementedError(this.deleteIfExists.name);
+	}
+	exists() {
+		throw new NotImplementedError(this.exists.name);
+	}
+	findBlobsByTags() {
+		throw new NotImplementedError(this.findBlobsByTags.name);
+	}
+	generateSasStringToSign() {
+		throw new NotImplementedError(this.generateSasStringToSign.name);
+	}
+	generateSasUrl(options) {
+		return Promise.resolve(getMockSasUrl(this.url, options.permissions, "c"));
+	}
+	generateUserDelegationSasStringToSign() {
+		throw new NotImplementedError(this.generateUserDelegationSasStringToSign.name);
+	}
+	generateUserDelegationSasUrl() {
+		throw new NotImplementedError(this.generateUserDelegationSasUrl.name);
+	}
+	getAccessPolicy() {
+		throw new NotImplementedError(this.getAccessPolicy.name);
+	}
+	getAccountInfo() {
+		throw new NotImplementedError(this.getAccountInfo.name);
+	}
+	getAppendBlobClient() {
+		throw new NotImplementedError(this.getAppendBlobClient.name);
+	}
+	getBlobBatchClient() {
+		return new MockBlobBatchClient(this.url);
+	}
+	getBlobClient(blobName) {
+		return new MockBlockBlobClient(this.connectionString, this.containerName, blobName);
+	}
+	getBlobLeaseClient() {
+		throw new NotImplementedError(this.getBlobLeaseClient.name);
+	}
+	getBlockBlobClient(blobName) {
+		return new MockBlockBlobClient(this.connectionString, this.containerName, blobName);
+	}
+	getPageBlobClient() {
+		throw new NotImplementedError(this.getPageBlobClient.name);
+	}
+	getProperties() {
+		throw new NotImplementedError(this.getProperties.name);
+	}
+	listBlobsByHierarchy(delimiter, options) {
+		const blobHierarchyItemIterator = this.#getBlobHierarchyItemIterator(delimiter, options);
+		return {
+			byPage: () => async function* () {
+				const allBlobItems = [];
+				const allBlobItemXml = [];
+				const allBlobPrefixes = [];
+				const allBlobPrefixXml = [];
+				for await (const blobHierarchyItem of blobHierarchyItemIterator) if (blobHierarchyItem.kind === "blob") {
+					allBlobItems.push(blobHierarchyItem);
+					allBlobItemXml.push(getBlobItemXml(blobHierarchyItem));
+				} else {
+					allBlobPrefixes.push({ name: blobHierarchyItem.name });
+					allBlobPrefixXml.push(getBlobPrefixXml(blobHierarchyItem.name));
+				}
+				if (allBlobItems.length > 0 || allBlobPrefixes.length > 0) yield await Promise.resolve(getListBlobsSegmentResponse(this.containerName, options?.prefix ?? "", {
+					blobItems: allBlobItems,
+					blobPrefixes: allBlobPrefixes
+				}, `${allBlobItemXml.join("")}${allBlobPrefixXml.join("")}`));
+			}.bind(this)(),
+			next: blobHierarchyItemIterator.next.bind(blobHierarchyItemIterator),
+			[Symbol.asyncIterator]() {
+				return this;
+			}
+		};
+	}
+	listBlobsFlat(options) {
+		const blobItemIterator = this.#getBlobItemIterator(options);
+		return {
+			byPage: () => async function* () {
+				const allBlobItems = [];
+				const allBlobItemXml = [];
+				for await (const blobItem of blobItemIterator) {
+					allBlobItems.push(blobItem);
+					allBlobItemXml.push(getBlobItemXml(blobItem));
+				}
+				if (allBlobItems.length > 0) yield await Promise.resolve(getListBlobsSegmentResponse(this.containerName, options?.prefix ?? "", { blobItems: allBlobItems }, allBlobItemXml.join("")));
+			}.bind(this)(),
+			next: blobItemIterator.next.bind(blobItemIterator),
+			[Symbol.asyncIterator]() {
+				return this;
+			}
+		};
+	}
+	setAccessPolicy() {
+		throw new NotImplementedError(this.setAccessPolicy.name);
+	}
+	setMetadata() {
+		throw new NotImplementedError(this.setMetadata.name);
+	}
+	async uploadBlockBlob(blobName, body, contentLength) {
+		const blockBlobClient = this.getBlockBlobClient(blobName);
+		return {
+			blockBlobClient,
+			response: await blockBlobClient.upload(body, contentLength)
+		};
+	}
+	async *#getBlobHierarchyItemIterator(delimiter, options) {
+		const prefix = options?.prefix ?? "";
+		const uniqueSubprefixes = /* @__PURE__ */ new Set();
+		const blobsInCurrentLevel = [];
+		for (const [name, buffer] of this.container.entries()) {
+			if (!name.startsWith(prefix)) continue;
+			const nameAfterPrefix = name.slice(prefix.length);
+			const delimiterIndex = nameAfterPrefix.indexOf(delimiter);
+			if (delimiterIndex === -1) blobsInCurrentLevel.push(this.#getBlobItem(name, buffer, options?.includeMetadata));
+			else {
+				const subprefix = `${prefix}${nameAfterPrefix.slice(0, delimiterIndex + delimiter.length)}`;
+				uniqueSubprefixes.add(subprefix);
+			}
+		}
+		for (const prefixName of [...uniqueSubprefixes].toSorted()) yield await Promise.resolve({
+			kind: "prefix",
+			name: prefixName
+		});
+		for (const blobItem of blobsInCurrentLevel) yield await Promise.resolve({
+			kind: "blob",
+			...blobItem
+		});
+	}
+	#getBlobItem(name, buffer, isMetadataIncluded) {
+		const { createdOn, etag, lastModified } = readMockBlobDates(this.containerName, name);
+		return {
+			deleted: false,
+			...isMetadataIncluded && { metadata: readMockBlobMetadata(this.containerName, name) },
+			name,
+			properties: {
+				blobType: "BlockBlob",
+				contentLength: buffer.length,
+				contentType: "application/octet-stream",
+				createdOn,
+				etag,
+				lastModified,
+				leaseState: "available",
+				leaseStatus: "unlocked"
+			},
+			snapshot: ""
+		};
+	}
+	async *#getBlobItemIterator(options) {
+		const prefix = options?.prefix ?? "";
+		for (const [name, buffer] of this.container.entries()) {
+			if (!name.startsWith(prefix)) continue;
+			yield await Promise.resolve(this.#getBlobItem(name, buffer, options?.includeMetadata));
+		}
+	}
+};
+// src/store/MockEventGridDatabase.ts
+const MockEventGridDatabase = /* @__PURE__ */ new Map();
+// src/models/eventGrid/MockEventGridPublisherClient.ts
+/**
+* An in-memory mock of the Azure EventGridPublisherClient — no emulator and no network.
+* `client` is excluded because it is a private member of the real class and cannot be satisfied structurally.
+*/
+var MockEventGridPublisherClient = class {
+	endpointUrl;
+	inputSchema;
+	topicType;
+	constructor(endpoint, topicType) {
+		this.endpointUrl = endpoint;
+		this.topicType = topicType;
+		this.inputSchema = topicType;
+	}
+	send(newEvents) {
+		getOrCreate(MockEventGridDatabase, this.endpointUrl, () => []).push(...newEvents);
+		return Promise.resolve();
+	}
+};
+// src/services/queue/getMockQueueMessageItem.ts
+const getMockQueueMessageItem = (messageText) => {
+	const insertedOn = /* @__PURE__ */ new Date();
+	return {
+		expiresOn: new Date(insertedOn.getTime() + AZURE_MAX_QUEUE_VISIBILITY_TIMEOUT_MS),
+		insertedOn,
+		messageId: crypto.randomUUID(),
+		messageText
+	};
+};
+// src/store/MockQueueDatabase.ts
+const MockQueueDatabase = /* @__PURE__ */ new Map();
+// src/models/queue/MockQueueClient.ts
+/**
+* An in-memory mock of the Azure QueueClient — no emulator and no network.
+*
+* @example
+* const mockQueueClient = new MockQueueClient("", "hello world");
+* await mockQueueClient.createIfNotExists();
+* await mockQueueClient.sendMessage("hello world");
+* const messages = await mockQueueClient.peekMessages();
+*/
+var MockQueueClient = class {
+	connectionString;
+	name;
+	url;
+	get queue() {
+		return getOrCreate(MockQueueDatabase, this.name, () => []);
+	}
+	constructor(connectionString, queueName) {
+		this.connectionString = connectionString;
+		this.name = queueName;
+		this.url = `${MOCK_QUEUE_BASE_URL}/${this.name}`;
+	}
+	clearMessages() {
+		throw new NotImplementedError(this.clearMessages.name);
+	}
+	create(_options) {
+		throw new NotImplementedError(this.create.name);
+	}
+	createIfNotExists() {
+		throw new NotImplementedError(this.createIfNotExists.name);
+	}
+	delete() {
+		throw new NotImplementedError(this.delete.name);
+	}
+	deleteIfExists() {
+		throw new NotImplementedError(this.deleteIfExists.name);
+	}
+	deleteMessage() {
+		throw new NotImplementedError(this.deleteMessage.name);
+	}
+	exists() {
+		throw new NotImplementedError(this.exists.name);
+	}
+	generateSasStringToSign() {
+		throw new NotImplementedError(this.generateSasStringToSign.name);
+	}
+	generateSasUrl(options) {
+		return getMockSasUrl(this.url, options.permissions);
+	}
+	generateUserDelegationSasUrl() {
+		throw new NotImplementedError(this.generateUserDelegationSasUrl.name);
+	}
+	generateUserDelegationStringToSign() {
+		throw new NotImplementedError(this.generateUserDelegationStringToSign.name);
+	}
+	getAccessPolicy() {
+		throw new NotImplementedError(this.getAccessPolicy.name);
+	}
+	getProperties() {
+		throw new NotImplementedError(this.getProperties.name);
+	}
+	getServiceProperties() {
+		throw new NotImplementedError(this.getServiceProperties.name);
+	}
+	listQueues() {
+		throw new NotImplementedError(this.listQueues.name);
+	}
+	peekMessages(_options) {
+		const peekedMessageItems = this.queue.map((text) => ({
+			dequeueCount: 0,
+			...getMockQueueMessageItem(text)
+		}));
+		return Promise.resolve({
+			_response: {
+				...createMockResponse(200, this.url),
+				bodyAsText: "",
+				parsedBody: peekedMessageItems
+			},
+			peekedMessageItems
+		});
+	}
+	receiveMessages(_options) {
+		const queuedTexts = this.queue;
+		MockQueueDatabase.set(this.name, []);
+		const receivedMessageItems = queuedTexts.map((text) => Object.assign(getMockQueueMessageItem(text), {
+			dequeueCount: 1,
+			nextVisibleOn: /* @__PURE__ */ new Date(),
+			popReceipt: crypto.randomUUID()
+		}));
+		return Promise.resolve({
+			_response: {
+				...createMockResponse(200, this.url),
+				bodyAsText: "",
+				parsedBody: receivedMessageItems
+			},
+			receivedMessageItems
+		});
+	}
+	sendMessage(messageText, _options) {
+		this.queue.push(messageText);
+		const { expiresOn, insertedOn, messageId } = getMockQueueMessageItem(messageText);
+		const enqueuedMessage = {
+			expiresOn,
+			insertedOn,
+			messageId,
+			nextVisibleOn: insertedOn,
+			popReceipt: crypto.randomUUID()
+		};
+		const enqueuedMessages = [enqueuedMessage];
+		return Promise.resolve({
+			_response: {
+				...createMockResponse(200, this.url),
+				bodyAsText: "",
+				parsedBody: enqueuedMessages
+			},
+			...enqueuedMessage
+		});
+	}
+	setAccessPolicy(_identifiers) {
+		throw new NotImplementedError(this.setAccessPolicy.name);
+	}
+	setMetadata() {
+		throw new NotImplementedError(this.setMetadata.name);
+	}
+	updateMessage() {
+		throw new NotImplementedError(this.updateMessage.name);
+	}
+};
+// src/services/filter/checkIsNullClause.ts
+const checkIsNullClause = (clause) => {
+	const tableNullClause = getTableNullClause(clause.key);
+	return checkIsDeepEqual(clause, tableNullClause);
+};
+// src/services/filter/compare.ts
+const compare = (operator, leftHandSide, rightHandSide) => {
+	if (rightHandSide === null || rightHandSide === void 0) {
+		if (operator !== BinaryOperator.Eq) throw new InvalidOperationError(Operation.Read, compare.name, JSON.stringify({
+			leftHandSide,
+			operator,
+			rightHandSide
+		}));
+		return leftHandSide === null || leftHandSide === void 0;
+	}
+	switch (operator) {
+		case BinaryOperator.Eq: return leftHandSide === rightHandSide;
+		case BinaryOperator.Ge: return leftHandSide >= rightHandSide;
+		case BinaryOperator.Gt: return leftHandSide > rightHandSide;
+		case BinaryOperator.Le: return leftHandSide <= rightHandSide;
+		case BinaryOperator.Lt: return leftHandSide < rightHandSide;
+		case BinaryOperator.Ne: return leftHandSide !== rightHandSide;
+		default: return exhaustiveGuard(operator);
+	}
+};
+// src/services/filter/createFilterPredicate.ts
+const createFilterPredicate = (filter) => {
+	const orGroups = filter.replaceAll(String.raw`(`, " ").replaceAll(String.raw`)`, "").split(/\s+and\s+/iu).filter(Boolean).map((group) => group.split(/\s+or\s+/iu).filter(Boolean).map((clauseString) => {
+		const clause = deserializeClause(clauseString);
+		return {
+			clause,
+			isNull: checkIsNullClause(clause)
+		};
+	}));
+	return (document) => {
+		for (const orGroup of orGroups) {
+			let isGroupMatched = false;
+			for (const { clause, isNull } of orGroup) {
+				const value = takeOne(document, clause.key);
+				let isMatched;
+				if (isNull) isMatched = compare(BinaryOperator.Eq, value, null);
+				else {
+					const comparisonResult = compare(clause.operator, value, clause.value);
+					isMatched = clause.not ? !comparisonResult : comparisonResult;
+				}
+				if (isMatched) {
+					isGroupMatched = true;
+					break;
+				}
+			}
+			if (!isGroupMatched) return false;
+		}
+		return true;
+	};
+};
+// src/store/MockSearchDatabase.ts
+const MockSearchDatabase = /* @__PURE__ */ new Map();
+// src/models/search/MockSearchClient.ts
+const toComparable = (value) => {
+	if (value instanceof Date) return value.getTime();
+	else if (typeof value === "number" || typeof value === "string") return value;
+	else return String(value);
+};
+const compareValues = (firstValue, secondValue) => {
+	const firstComparable = toComparable(firstValue);
+	const secondComparable = toComparable(secondValue);
+	if (typeof firstComparable === "number" && typeof secondComparable === "number") return firstComparable - secondComparable;
+	else return String(firstComparable).localeCompare(String(secondComparable));
+};
+const sortDocuments = (documents, orderBy) => {
+	const parsedOrderBy = orderBy.map((clause) => {
+		const [field = "", direction = "asc"] = clause.split(/\s+/u);
+		return {
+			direction,
+			key: deserializeKey(field)
+		};
+	});
+	return documents.toSorted((firstDocument, secondDocument) => {
+		for (const { direction, key } of parsedOrderBy) {
+			const comparison = compareValues(firstDocument[key], secondDocument[key]);
+			if (comparison !== 0) return direction === "desc" ? -comparison : comparison;
+		}
+		return 0;
+	});
+};
+const getSearchFieldValues = (value, pathSegments) => {
+	if (pathSegments.length === 0) return [value];
+	else if (Array.isArray(value)) return value.flatMap((item) => getSearchFieldValues(item, pathSegments));
+	else if (typeof value === "object" && value !== null) {
+		const [field = "", ...remainingPathSegments] = pathSegments;
+		return getSearchFieldValues(value[deserializeKey(field)], remainingPathSegments);
+	} else return [];
+};
+const searchDocuments = (documents, searchText, searchFields) => {
+	if (!searchText || searchText === "*") return documents;
+	const normalizedSearchText = searchText.toLocaleLowerCase();
+	const searchFieldPaths = searchFields?.map((searchField) => searchField.split("/"));
+	return documents.filter((document) => (searchFieldPaths ?? Object.keys(document).map((field) => field.split("/"))).some((pathSegments) => getSearchFieldValues(document, pathSegments).some((value) => typeof value === "string" && value.toLocaleLowerCase().includes(normalizedSearchText))));
+};
+/**
+* An in-memory mock of the Azure SearchClient — no emulator and no network. It applies the same OData filtering
+* as the other mock clients, so a query behaves the same here as it does against the service.
+*
+* @example
+* const mockSearchClient = new MockSearchClient(SearchIndex.Messages);
+* await mockSearchClient.uploadDocuments([{ ... }]);
+* const { count, results } = await mockSearchClient.search("*", { filter, includeTotalCount: true });
+*/
+var MockSearchClient = class {
+	apiVersion = "";
+	endpoint = MOCK_SEARCH_BASE_URL;
+	indexName;
+	serviceVersion = "";
+	get documents() {
+		return getOrCreate(MockSearchDatabase, this.indexName, () => []);
+	}
+	constructor(indexName) {
+		this.indexName = indexName;
+	}
+	autocomplete() {
+		throw new NotImplementedError(this.autocomplete.name);
+	}
+	deleteDocuments() {
+		throw new NotImplementedError(this.deleteDocuments.name);
+	}
+	getDocument(_key, _options) {
+		throw new NotImplementedError(this.getDocument.name);
+	}
+	getDocumentsCount(_options) {
+		return Promise.resolve(this.documents.length);
+	}
+	indexDocuments(_batch, _options) {
+		throw new NotImplementedError(this.indexDocuments.name);
+	}
+	mergeDocuments(_documents, _options) {
+		throw new NotImplementedError(this.mergeDocuments.name);
+	}
+	mergeOrUploadDocuments(_documents, _options) {
+		throw new NotImplementedError(this.mergeOrUploadDocuments.name);
+	}
+	search(searchText, options) {
+		const { filter, includeTotalCount, orderBy, searchFields, skip = 0, top } = options ?? {};
+		let documents = searchDocuments(this.documents, searchText, searchFields);
+		if (filter) {
+			const predicate = createFilterPredicate(filter);
+			documents = documents.filter((document) => predicate(document));
+		}
+		if (orderBy) documents = sortDocuments(documents, orderBy);
+		const count = documents.length;
+		const paginatedDocuments = documents.slice(skip, top === void 0 ? void 0 : skip + top);
+		const results = { async *[Symbol.asyncIterator]() {
+			for (const document of paginatedDocuments) yield { document };
+		} };
+		return Promise.resolve({
+			...includeTotalCount ? { count } : {},
+			results
+		});
+	}
+	suggest(_searchText, _suggesterName, _options) {
+		throw new NotImplementedError(this.suggest.name);
+	}
+	uploadDocuments(documents, _options) {
+		this.documents.push(...documents);
+		return Promise.resolve({ results: [] });
+	}
+};
+// src/store/MockServiceBusDatabase.ts
+const MockServiceBusDatabase = /* @__PURE__ */ new Map();
+// src/models/serviceBus/MockServiceBusSender.ts
+/**
+* An in-memory mock of the Azure ServiceBusSender — no emulator and no network.
+*
+* @example
+* const mockServiceBusSender = new MockServiceBusSender("hello world");
+* await mockServiceBusSender.scheduleMessages({ body: "hello world" }, new Date());
+*/
+var MockServiceBusSender = class {
+	entityPath;
+	identifier;
+	isClosed = false;
+	get queue() {
+		return getOrCreate(MockServiceBusDatabase, this.entityPath, () => []);
+	}
+	constructor(queueName) {
+		this.entityPath = queueName;
+		this.identifier = queueName;
+	}
+	cancelScheduledMessages() {
+		throw new NotImplementedError(this.cancelScheduledMessages.name);
+	}
+	close() {
+		this.isClosed = true;
+		return Promise.resolve();
+	}
+	createMessageBatch() {
+		throw new NotImplementedError(this.createMessageBatch.name);
+	}
+	scheduleMessages(messages, scheduledEnqueueTimeUtc) {
+		for (const message of Array.isArray(messages) ? messages : [messages]) this.queue.push({
+			...message,
+			scheduledEnqueueTimeUtc
+		});
+		return Promise.resolve([]);
+	}
+	sendMessages(messages) {
+		if (!Array.isArray(messages) && "tryAddMessage" in messages) throw new NotImplementedError(`${this.sendMessages.name}(ServiceBusMessageBatch)`);
+		this.queue.push(...Array.isArray(messages) ? messages : [messages]);
+		return Promise.resolve();
+	}
+};
+// src/services/table/compareByCompositeKey.ts
+const compareByCompositeKey = (firstEntity, secondEntity) => {
+	if (firstEntity.partitionKey !== secondEntity.partitionKey) return firstEntity.partitionKey < secondEntity.partitionKey ? -1 : 1;
+	else if (firstEntity.rowKey === secondEntity.rowKey) return 0;
+	else return firstEntity.rowKey < secondEntity.rowKey ? -1 : 1;
+};
+// src/store/MockTableDatabase.ts
+const MockTableDatabase = /* @__PURE__ */ new Map();
+// src/models/table/MockTableClient.ts
+/**
+* An in-memory mock of the Azure TableClient — no emulator and no network.
+*
+* @example
+* const mockTableClient = new MockTableClient("", "hello world");
+* await mockTableClient.createEntity({ partitionKey: "partitionKey", rowKey: "rowKey" });
+* const entity = await mockTableClient.getEntity("partitionKey", "rowKey");
+*/
+var MockTableClient = class {
+	tableName;
+	url;
+	get table() {
+		return getOrCreate(MockTableDatabase, this.tableName, () => /* @__PURE__ */ new Map());
+	}
+	constructor(_url, tableName) {
+		this.tableName = tableName;
+		this.url = `${MOCK_TABLE_BASE_URL}/${this.tableName}`;
+	}
+	createEntity(entity) {
+		this.#applyCreate(entity);
+		return Promise.resolve({
+			date: /* @__PURE__ */ new Date(),
+			etag: this.#getEtag()
+		});
+	}
+	createTable() {
+		throw new NotImplementedError(this.createTable.name);
+	}
+	deleteEntity(partitionKey, rowKey, options) {
+		this.#applyDelete(partitionKey, rowKey, options?.etag);
+		return Promise.resolve({});
+	}
+	deleteTable() {
+		throw new NotImplementedError(this.deleteTable.name);
+	}
+	getAccessPolicy() {
+		throw new NotImplementedError(this.getAccessPolicy.name);
+	}
+	getEntity(partitionKey, rowKey) {
+		const key = this.#getCompositeKey(partitionKey, rowKey);
+		const entity = this.table.get(key);
+		if (!entity) throw new MockRestError("The specified resource does not exist.", 404);
+		return Promise.resolve({
+			...entity,
+			etag: entity.etag ?? this.#getEtag()
+		});
+	}
+	listEntities(options) {
+		const withMetadata = this.#withMetadata.bind(this);
+		const filter = options?.queryOptions?.filter;
+		const tableEntities = [...this.table.values()];
+		const predicate = filter ? createFilterPredicate(filter) : void 0;
+		const resultTableEntities = (predicate ? tableEntities.filter((entity) => predicate(entity)) : tableEntities).toSorted(compareByCompositeKey);
+		const entityIterator = (async function* (entities) {
+			for (const entity of entities) yield await Promise.resolve(withMetadata(entity));
+		})(resultTableEntities);
+		return {
+			byPage: ({ maxPageSize } = {}) => (async function* (entities) {
+				if (maxPageSize !== void 0 && maxPageSize <= 0) throw new RangeError("maxPageSize must be greater than 0.");
+				else if (maxPageSize !== void 0 && maxPageSize > AZURE_MAX_PAGE_SIZE) throw new MockRestError("One of the request inputs is not valid.", 400);
+				if (entities.length === 0) return;
+				else if (!maxPageSize) {
+					yield await Promise.resolve(entities.map((entity) => withMetadata(entity)));
+					return;
+				}
+				for (const page of chunk(entities, maxPageSize)) yield await Promise.resolve(page.map((entity) => withMetadata(entity)));
+			})(resultTableEntities),
+			next: () => entityIterator.next(),
+			[Symbol.asyncIterator]() {
+				return this;
+			}
+		};
+	}
+	setAccessPolicy() {
+		throw new NotImplementedError(this.setAccessPolicy.name);
+	}
+	submitTransaction(actions) {
+		let partitionKey;
+		for (const [, entity] of actions) if (partitionKey === void 0) partitionKey = entity.partitionKey;
+		else if (entity.partitionKey !== partitionKey) throw new MockRestError("All transaction actions must target the same partitionKey.", 400);
+		const snapshot = new Map(this.table);
+		getResult(() => {
+			for (const [type, entity, updateMode] of actions) switch (type) {
+				case "create":
+					this.#applyCreate(entity);
+					break;
+				case "delete":
+					this.#applyDelete(entity.partitionKey, entity.rowKey);
+					break;
+				case "update":
+					this.#applyUpdate(entity, updateMode);
+					break;
+				case "upsert":
+					this.#applyUpsert(entity, updateMode);
+					break;
+				default: exhaustiveGuard(type);
+			}
+		}).orTee(() => {
+			this.table.clear();
+			for (const [key, value] of snapshot) this.table.set(key, value);
+		}).match(noop, (error) => {
+			throw error;
+		});
+		return Promise.resolve({
+			getResponseForEntity: () => void 0,
+			status: 202,
+			subResponses: []
+		});
+	}
+	updateEntity(entity, mode = "Merge", options) {
+		this.#applyUpdate(entity, mode, options?.etag);
+		return Promise.resolve({
+			date: /* @__PURE__ */ new Date(),
+			etag: this.#getEtag()
+		});
+	}
+	upsertEntity(entity, mode = "Merge") {
+		this.#applyUpsert(entity, mode);
+		return Promise.resolve({
+			date: /* @__PURE__ */ new Date(),
+			etag: this.#getEtag()
+		});
+	}
+	#applyCreate(entity) {
+		const key = this.#getCompositeKey(entity.partitionKey, entity.rowKey);
+		if (this.table.has(key)) throw new MockRestError("The specified entity already exists.", 409);
+		this.table.set(key, {
+			...entity,
+			etag: this.#getEtag()
+		});
+	}
+	#applyDelete(partitionKey, rowKey, etag) {
+		const key = this.#getCompositeKey(partitionKey, rowKey);
+		const existingEntity = this.table.get(key);
+		if (!existingEntity) throw new MockRestError("The specified resource does not exist.", 404);
+		this.#assertEtag(existingEntity.etag, etag);
+		this.table.delete(key);
+	}
+	#applyUpdate(entity, mode = "Merge", etag) {
+		const key = this.#getCompositeKey(entity.partitionKey, entity.rowKey);
+		const existingEntity = this.table.get(key);
+		if (!existingEntity) throw new MockRestError("The specified resource does not exist.", 404);
+		this.#assertEtag(existingEntity.etag, etag);
+		this.#writeEntity(key, entity, mode, existingEntity);
+	}
+	#applyUpsert(entity, mode = "Merge") {
+		const key = this.#getCompositeKey(entity.partitionKey, entity.rowKey);
+		const existingEntity = this.table.get(key);
+		this.#writeEntity(key, entity, mode, existingEntity);
+	}
+	#assertEtag(existingEtag, etag) {
+		if (etag !== void 0 && etag !== "*" && etag !== existingEtag) throw new MockRestError("The update condition specified in the request was not satisfied.", 412);
+	}
+	#getCompositeKey(partitionKey, rowKey) {
+		return `${encodeURIComponent(partitionKey)}${ID_SEPARATOR}${encodeURIComponent(rowKey)}`;
+	}
+	#getEtag() {
+		return `W/"${crypto.randomUUID()}"`;
+	}
+	#withMetadata(entity) {
+		return {
+			...entity,
+			etag: entity.etag ?? this.#getEtag()
+		};
+	}
+	#writeEntity(key, entity, mode, existingEntity) {
+		if (existingEntity && mode === "Merge") this.table.set(key, {
+			...existingEntity,
+			...entity,
+			etag: this.#getEtag()
+		});
+		else this.table.set(key, {
+			...entity,
+			etag: this.#getEtag()
+		});
+	}
+};
+// src/models/webPubSub/MockWebPubSubServiceClient.ts
+/**
+* A minimal mock of the Azure WebPubSubServiceClient for testing purposes.
+* Only implements `group().sendToAll` — the only method used in azure-functions tests.
+*/
+var MockWebPubSubServiceClient = class {
+	group(_groupName) {
+		return { sendToAll: () => Promise.resolve() };
+	}
+};
+// src/services/filter/applyFilter.ts
+const applyFilter = (documents, clauses) => {
+	const predicate = createFilterPredicate(serializeClauses(clauses));
+	return documents.filter((document) => predicate(document));
+};
+export { BLOB_NOT_FOUND_ERROR_CODE, BLOB_NOT_FOUND_MESSAGE, CONDITION_NOT_MET_ERROR_CODE, CONDITION_NOT_MET_MESSAGE, MOCK_BLOB_BASE_URL, MOCK_BLOB_SEEDED_DATE, MOCK_BLOB_SEEDED_PROPERTIES, MOCK_QUEUE_BASE_URL, MOCK_SEARCH_BASE_URL, MOCK_TABLE_BASE_URL, MockBlobBatchClient, MockBlobClient, MockBlockBlobClient, MockContainerBlobDatesDatabase, MockContainerBlobMetadataDatabase, MockContainerClient, MockContainerDatabase, MockEventGridDatabase, MockEventGridPublisherClient, MockQueueClient, MockQueueDatabase, MockRestError, MockSearchClient, MockSearchDatabase, MockServiceBusDatabase, MockServiceBusSender, MockTableClient, MockTableDatabase, MockWebPubSubServiceClient, NotImplementedError, applyFilter, bodyToBuffer, checkIsNullClause, checkIsReadableStream, compare, compareByCompositeKey, createFilterPredicate, createMockResponse, deleteMockBlob, getAzureErrorXml, getBlobItemXml, getBlobPrefixXml, getBlobUrl, getBlobUrlParts, getListBlobsSegmentResponse, getListBlobsXml, getMockBlobKey, getMockContainer, getMockQueueMessageItem, getMockSasUrl, readMockBlobDates, readMockBlobMetadata, storeMockBlobMetadata, storeMockBlobWrite, toWebResourceLike };