azure-mock 4.2.0 → 4.3.1

package/dist/index.d.ts

@@ -0,0 +1,1240 @@
+import { HttpHeadersLike, WebResourceLike } from "@azure/core-http-compat";
+import { PipelineRequest, RestError } from "@azure/core-rest-pipeline";
+import { AnonymousCredential, AppendBlobClient, BlobAbortCopyFromURLResponse, BlobBatchClient, BlobBatchDeleteBlobsResponse, BlobBeginCopyFromURLResponse, BlobClient, BlobCopyFromURLResponse, BlobCreateSnapshotResponse, BlobDeleteIfExistsResponse, BlobDeleteImmutabilityPolicyResponse, BlobDeleteOptions, BlobDeleteResponse, BlobDownloadResponseModel, BlobDownloadResponseParsed, BlobGenerateSasUrlOptions, BlobGetAccountInfoResponse, BlobGetPropertiesResponse, BlobGetTagsResponse, BlobHierarchyListSegment, BlobItem, BlobLeaseClient, BlobPrefix, BlobSetHTTPHeadersResponse, BlobSetImmutabilityPolicyResponse, BlobSetLegalHoldResponse, BlobSetMetadataResponse, BlobSetTagsResponse, BlobSetTierResponse, BlobUndeleteResponse, BlobUploadCommonResponse, BlockBlobClient, BlockBlobCommitBlockListResponse, BlockBlobGetBlockListResponse, BlockBlobPutBlobFromUrlResponse, BlockBlobStageBlockFromURLResponse, BlockBlobStageBlockResponse, BlockBlobUploadOptions, BlockBlobUploadResponse, ContainerClient, ContainerCreateIfNotExistsResponse, ContainerCreateResponse, ContainerDeleteIfExistsResponse, ContainerDeleteResponse, ContainerFindBlobsByTagsSegmentResponse, ContainerGenerateSasUrlOptions, ContainerGetAccessPolicyResponse, ContainerGetAccountInfoResponse, ContainerGetPropertiesResponse, ContainerListBlobFlatSegmentResponse, ContainerListBlobHierarchySegmentResponse, ContainerListBlobsOptions, ContainerSetAccessPolicyResponse, ContainerSetMetadataResponse, FilterBlobItem, HttpRequestBody, Metadata, PageBlobClient, PollOperationState, PollerLikeWithCancellation, StorageSharedKeyCredential } from "@azure/storage-blob";
+import { BinaryOperator, Clause } from "@esposter/azure";
+import { EventGridEvent, EventGridPublisherClient } from "@azure/eventgrid";
+import { QueueClearMessagesResponse, QueueClient, QueueCreateIfNotExistsResponse, QueueCreateOptions, QueueCreateResponse, QueueDeleteIfExistsResponse, QueueDeleteMessageResponse, QueueDeleteResponse, QueueGenerateSasUrlOptions, QueueGetAccessPolicyResponse, QueueGetPropertiesResponse, QueueItem, QueuePeekMessagesOptions, QueuePeekMessagesResponse, QueueReceiveMessageOptions, QueueReceiveMessageResponse, QueueSendMessageOptions, QueueSendMessageResponse, QueueServiceProperties, QueueSetAccessPolicyResponse, QueueSetMetadataResponse, QueueUpdateMessageResponse, SignedIdentifier } from "@azure/storage-queue";
+import { AutocompleteResult, CountDocumentsOptions, DeleteDocumentsOptions, GetDocumentOptions, IndexDocumentsBatch, IndexDocumentsOptions, IndexDocumentsResult, MergeDocumentsOptions, MergeOrUploadDocumentsOptions, NarrowedModel, SearchClient, SearchDocumentsResult, SearchOptions, SelectFields, SuggestDocumentsResult, SuggestOptions, UploadDocumentsOptions } from "@azure/search-documents";
+import { ServiceBusMessage, ServiceBusMessageBatch, ServiceBusSender } from "@azure/service-bus";
+import { CreateTableEntityResponse, GetAccessPolicyResponse, GetTableEntityResponse, ListTableEntitiesOptions, TableClient, TableDeleteEntityHeaders, TableEntity, TableEntityResult, TableEntityResultPage, TableMergeEntityHeaders, TableSetAccessPolicyHeaders, TableTransactionResponse, UpdateMode } from "@azure/data-tables";
+//#region src/constants.d.ts
+export declare const BLOB_NOT_FOUND_ERROR_CODE = "BlobNotFound";
+export declare const BLOB_NOT_FOUND_MESSAGE = "The specified blob does not exist.";
+export declare const CONDITION_NOT_MET_ERROR_CODE = "ConditionNotMet";
+export declare const CONDITION_NOT_MET_MESSAGE = "The condition specified using HTTP conditional header(s) is not met.";
+export declare const MOCK_BLOB_BASE_URL = "https://mockaccount.blob.core.windows.net";
+export declare const MOCK_QUEUE_BASE_URL = "https://mockaccount.queue.core.windows.net";
+export declare const MOCK_SEARCH_BASE_URL = "https://mockaccount.search.windows.net";
+export declare const MOCK_TABLE_BASE_URL = "https://mockaccount.table.core.windows.net";
+//#endregion
+//#region src/models/container/BlobHierarchyItem.d.ts
+export type BlobHierarchyItem = (BlobItem & {
+  kind: "blob";
+}) | (BlobPrefix & {
+  kind: "prefix";
+});
+//#endregion
+//#region src/store/MockContainerDatabase.d.ts
+export declare const MockContainerDatabase: Map<string, Map<string, Buffer>>;
+//#endregion
+//#region src/util/types/MapValue.d.ts
+export type MapValue<BaseType> = BaseType extends Map<unknown, infer ValueType> ? ValueType : never;
+//#endregion
+//#region src/models/container/MockBlobBatchClient.d.ts
+export declare class MockBlobBatchClient implements BlobBatchClient {
+  #private;
+  url: string;
+  constructor(url: string);
+  /**
+   * 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: string[], credential: AnonymousCredential | StorageSharedKeyCredential, options?: BlobDeleteOptions): Promise<BlobBatchDeleteBlobsResponse>;
+  getContainer(containerName: string): MapValue<typeof MockContainerDatabase>;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.10.0/node_modules/type-fest/source/is-any.d.ts
+/**
+Returns a boolean for whether the given type is `any`.
+
+@link https://stackoverflow.com/a/49928360/1490091
+
+Useful in type utilities, such as disallowing `any`s to be passed to a function.
+
+@example
+```
+import type {IsAny} from 'type-fest';
+
+const typedObject = {a: 1, b: 2} as const;
+const anyObject: any = {a: 1, b: 2};
+
+function get<O extends (IsAny<O> extends true ? {} : Record<string, number>), K extends keyof O = keyof O>(object: O, key: K) {
+	return object[key];
+}
+
+const typedA = get(typedObject, 'a');
+//=> 1
+
+const anyA = get(anyObject, 'a');
+//=> any
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsAny<T> = 0 extends 1 & NoInfer<T> ? true : false;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.10.0/node_modules/type-fest/source/is-optional-key-of.d.ts
+/**
+Returns a boolean for whether the given key is an optional key of type.
+
+This is useful when writing utility types or schema validators that need to differentiate `optional` keys.
+
+@example
+```
+import type {IsOptionalKeyOf} from 'type-fest';
+
+type User = {
+	name: string;
+	surname: string;
+
+	luckyNumber?: number;
+};
+
+type Admin = {
+	name: string;
+	surname?: string;
+};
+
+type T1 = IsOptionalKeyOf<User, 'luckyNumber'>;
+//=> true
+
+type T2 = IsOptionalKeyOf<User, 'name'>;
+//=> false
+
+type T3 = IsOptionalKeyOf<User, 'name' | 'luckyNumber'>;
+//=> boolean
+
+type T4 = IsOptionalKeyOf<User | Admin, 'name'>;
+//=> false
+
+type T5 = IsOptionalKeyOf<User | Admin, 'surname'>;
+//=> boolean
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsOptionalKeyOf<Type extends object, Key extends keyof Type> = IsAny<Type | Key> extends true ? never : Key extends keyof Type ? Type extends Record<Key, Type[Key]> ? false : true : false;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.10.0/node_modules/type-fest/source/optional-keys-of.d.ts
+/**
+Extract all optional keys from the given type.
+
+This is useful when you want to create a new type that contains different type values for the optional keys only.
+
+@example
+```
+import type {OptionalKeysOf, Except} from 'type-fest';
+
+type User = {
+	name: string;
+	surname: string;
+
+	luckyNumber?: number;
+};
+
+const REMOVE_FIELD = Symbol('remove field symbol');
+type UpdateOperation<Entity extends object> = Except<Partial<Entity>, OptionalKeysOf<Entity>> & {
+	[Key in OptionalKeysOf<Entity>]?: Entity[Key] | typeof REMOVE_FIELD;
+};
+
+const update1: UpdateOperation<User> = {
+	name: 'Alice',
+};
+
+const update2: UpdateOperation<User> = {
+	name: 'Bob',
+	luckyNumber: REMOVE_FIELD,
+};
+```
+
+@category Utilities
+*/
+type OptionalKeysOf<Type extends object> = Type extends unknown // For distributing `Type`
+ ? (keyof { [Key in keyof Type as IsOptionalKeyOf<Type, Key> extends false ? never : Key]: never; }) & keyof Type // Intersect with `keyof Type` to ensure result of `OptionalKeysOf<Type>` is always assignable to `keyof Type`
+ : never; // Should never happen
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.10.0/node_modules/type-fest/source/required-keys-of.d.ts
+/**
+Extract all required keys from the given type.
+
+This is useful when you want to create a new type that contains different type values for the required keys only or use the list of keys for validation purposes, etc...
+
+@example
+```
+import type {RequiredKeysOf} from 'type-fest';
+
+declare function createValidation<
+	Entity extends object,
+	Key extends RequiredKeysOf<Entity> = RequiredKeysOf<Entity>,
+>(field: Key, validator: (value: Entity[Key]) => boolean): (entity: Entity) => boolean;
+
+type User = {
+	name: string;
+	surname: string;
+	luckyNumber?: number;
+};
+
+const validator1 = createValidation<User>('name', value => value.length < 25);
+const validator2 = createValidation<User>('surname', value => value.length < 25);
+
+// @ts-expect-error
+const validator3 = createValidation<User>('luckyNumber', value => value > 0);
+// Error: Argument of type '"luckyNumber"' is not assignable to parameter of type '"name" | "surname"'.
+```
+
+@category Utilities
+*/
+type RequiredKeysOf<Type extends object> = Type extends unknown // For distributing `Type`
+ ? Exclude<keyof Type, OptionalKeysOf<Type>> : never; // Should never happen
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.10.0/node_modules/type-fest/source/is-never.d.ts
+/**
+Returns a boolean for whether the given type is `never`.
+
+@link https://github.com/microsoft/TypeScript/issues/31751#issuecomment-498526919
+@link https://stackoverflow.com/a/53984913/10292952
+@link https://www.zhenghao.io/posts/ts-never
+
+Useful in type utilities, such as checking if something does not occur.
+
+@example
+```
+import type {IsNever, And} from 'type-fest';
+
+type A = IsNever<never>;
+//=> true
+
+type B = IsNever<any>;
+//=> false
+
+type C = IsNever<unknown>;
+//=> false
+
+type D = IsNever<never[]>;
+//=> false
+
+type E = IsNever<object>;
+//=> false
+
+type F = IsNever<string>;
+//=> false
+```
+
+@example
+```
+import type {IsNever} from 'type-fest';
+
+type IsTrue<T> = T extends true ? true : false;
+
+// When a distributive conditional is instantiated with `never`, the entire conditional results in `never`.
+type A = IsTrue<never>;
+//=> never
+
+// If you don't want that behaviour, you can explicitly add an `IsNever` check before the distributive conditional.
+type IsTrueFixed<T> =
+	IsNever<T> extends true ? false : T extends true ? true : false;
+
+type B = IsTrueFixed<never>;
+//=> false
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsNever<T> = [T] extends [never] ? true : false;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.10.0/node_modules/type-fest/source/if.d.ts
+/**
+An if-else-like type that resolves depending on whether the given `boolean` type is `true` or `false`.
+
+Use-cases:
+- You can use this in combination with `Is*` types to create an if-else-like experience. For example, `If<IsAny<any>, 'is any', 'not any'>`.
+
+Note:
+- Returns a union of if branch and else branch if the given type is `boolean` or `any`. For example, `If<boolean, 'Y', 'N'>` will return `'Y' | 'N'`.
+- Returns the else branch if the given type is `never`. For example, `If<never, 'Y', 'N'>` will return `'N'`.
+
+@example
+```
+import type {If} from 'type-fest';
+
+type A = If<true, 'yes', 'no'>;
+//=> 'yes'
+
+type B = If<false, 'yes', 'no'>;
+//=> 'no'
+
+type C = If<boolean, 'yes', 'no'>;
+//=> 'yes' | 'no'
+
+type D = If<any, 'yes', 'no'>;
+//=> 'yes' | 'no'
+
+type E = If<never, 'yes', 'no'>;
+//=> 'no'
+```
+
+@example
+```
+import type {If, IsAny, IsNever} from 'type-fest';
+
+type A = If<IsAny<unknown>, 'is any', 'not any'>;
+//=> 'not any'
+
+type B = If<IsNever<never>, 'is never', 'not never'>;
+//=> 'is never'
+```
+
+@example
+```
+import type {If, IsEqual} from 'type-fest';
+
+type IfEqual<T, U, IfBranch, ElseBranch> = If<IsEqual<T, U>, IfBranch, ElseBranch>;
+
+type A = IfEqual<string, string, 'equal', 'not equal'>;
+//=> 'equal'
+
+type B = IfEqual<string, number, 'equal', 'not equal'>;
+//=> 'not equal'
+```
+
+Note: Sometimes using the `If` type can make an implementation non–tail-recursive, which can impact performance. In such cases, it’s better to use a conditional directly. Refer to the following example:
+
+@example
+```
+import type {If, IsEqual, StringRepeat} from 'type-fest';
+
+type HundredZeroes = StringRepeat<'0', 100>;
+
+// The following implementation is not tail recursive
+type Includes<S extends string, Char extends string> =
+	S extends `${infer First}${infer Rest}`
+		? If<IsEqual<First, Char>,
+			'found',
+			Includes<Rest, Char>>
+		: 'not found';
+
+// Hence, instantiations with long strings will fail
+// @ts-expect-error
+type Fails = Includes<HundredZeroes, '1'>;
+//           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Error: Type instantiation is excessively deep and possibly infinite.
+
+// However, if we use a simple conditional instead of `If`, the implementation becomes tail-recursive
+type IncludesWithoutIf<S extends string, Char extends string> =
+	S extends `${infer First}${infer Rest}`
+		? IsEqual<First, Char> extends true
+			? 'found'
+			: IncludesWithoutIf<Rest, Char>
+		: 'not found';
+
+// Now, instantiations with long strings will work
+type Works = IncludesWithoutIf<HundredZeroes, '1'>;
+//=> 'not found'
+```
+
+@category Type Guard
+@category Utilities
+*/
+type If<Type extends boolean, IfBranch, ElseBranch> = IsNever<Type> extends true ? ElseBranch : Type extends true ? IfBranch : ElseBranch;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.10.0/node_modules/type-fest/source/simplify.d.ts
+/**
+Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
+
+@example
+```
+import type {Simplify} from 'type-fest';
+
+type PositionProps = {
+	top: number;
+	left: number;
+};
+
+type SizeProps = {
+	width: number;
+	height: number;
+};
+
+// In your editor, hovering over `Props` will show a flattened object with all the properties.
+type Props = Simplify<PositionProps & SizeProps>;
+```
+
+Sometimes it is desired to pass a value as a function argument that has a different type. At first inspection it may seem assignable, and then you discover it is not because the `value`'s type definition was defined as an interface. In the following example, `fn` requires an argument of type `Record<string, unknown>`. If the value is defined as a literal, then it is assignable. And if the `value` is defined as type using the `Simplify` utility the value is assignable.  But if the `value` is defined as an interface, it is not assignable because the interface is not sealed and elsewhere a non-string property could be added to the interface.
+
+If the type definition must be an interface (perhaps it was defined in a third-party npm package), then the `value` can be defined as `const value: Simplify<SomeInterface> = ...`. Then `value` will be assignable to the `fn` argument.  Or the `value` can be cast as `Simplify<SomeInterface>` if you can't re-declare the `value`.
+
+@example
+```
+import type {Simplify} from 'type-fest';
+
+interface SomeInterface {
+	foo: number;
+	bar?: string;
+	baz: number | undefined;
+}
+
+type SomeType = {
+	foo: number;
+	bar?: string;
+	baz: number | undefined;
+};
+
+const literal = {foo: 123, bar: 'hello', baz: 456};
+const someType: SomeType = literal;
+const someInterface: SomeInterface = literal;
+
+declare function fn(object: Record<string, unknown>): void;
+
+fn(literal); // Good: literal object type is sealed
+fn(someType); // Good: type is sealed
+// @ts-expect-error
+fn(someInterface); // Error: Index signature for type 'string' is missing in type 'someInterface'. Because `interface` can be re-opened
+fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface` into a `type`
+```
+
+@link https://github.com/microsoft/TypeScript/issues/15300
+@see {@link SimplifyDeep}
+@category Object
+*/
+type Simplify<T> = { [KeyType in keyof T]: T[KeyType]; } & {};
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.10.0/node_modules/type-fest/source/is-equal.d.ts
+/**
+Returns a boolean for whether the two given types are equal.
+
+@link https://github.com/microsoft/TypeScript/issues/27024#issuecomment-421529650
+@link https://stackoverflow.com/questions/68961864/how-does-the-equals-work-in-typescript/68963796#68963796
+
+Use-cases:
+- If you want to make a conditional branch based on the result of a comparison of two types.
+
+@example
+```
+import type {IsEqual} from 'type-fest';
+
+// This type returns a boolean for whether the given array includes the given item.
+// `IsEqual` is used to compare the given array at position 0 and the given item and then return true if they are equal.
+type Includes<Value extends readonly any[], Item> =
+	Value extends readonly [Value[0], ...infer rest]
+		? IsEqual<Value[0], Item> extends true
+			? true
+			: Includes<rest, Item>
+		: false;
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsEqual<A, B> = [A] extends [B] ? [B] extends [A] ? _IsEqual<A, B> : false : false;
+// This version fails the `equalWrappedTupleIntersectionToBeNeverAndNeverExpanded` test in `test-d/is-equal.ts`.
+type _IsEqual<A, B> = (<G>() => G extends A & G | G ? 1 : 2) extends (<G>() => G extends B & G | G ? 1 : 2) ? true : false;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.10.0/node_modules/type-fest/source/omit-index-signature.d.ts
+/**
+Omit any index signatures from the given object type, leaving only explicitly defined properties.
+
+This is the counterpart of `PickIndexSignature`.
+
+Use-cases:
+- Remove overly permissive signatures from third-party types.
+
+This type was taken from this [StackOverflow answer](https://stackoverflow.com/a/68261113/420747).
+
+It relies on the fact that an empty object (`{}`) is assignable to an object with just an index signature, like `Record<string, unknown>`, but not to an object with explicitly defined keys, like `Record<'foo' | 'bar', unknown>`.
+
+(The actual value type, `unknown`, is irrelevant and could be any type. Only the key type matters.)
+
+```
+const indexed: Record<string, unknown> = {}; // Allowed
+
+// @ts-expect-error
+const keyed: Record<'foo', unknown> = {}; // Error
+// TS2739: Type '{}' is missing the following properties from type 'Record<"foo" | "bar", unknown>': foo, bar
+```
+
+Instead of causing a type error like the above, you can also use a [conditional type](https://www.typescriptlang.org/docs/handbook/2/conditional-types.html) to test whether a type is assignable to another:
+
+```
+type Indexed = {} extends Record<string, unknown>
+	? '✅ `{}` is assignable to `Record<string, unknown>`'
+	: '❌ `{}` is NOT assignable to `Record<string, unknown>`';
+
+type IndexedResult = Indexed;
+//=> '✅ `{}` is assignable to `Record<string, unknown>`'
+
+type Keyed = {} extends Record<'foo' | 'bar', unknown>
+	? '✅ `{}` is assignable to `Record<\'foo\' | \'bar\', unknown>`'
+	: '❌ `{}` is NOT assignable to `Record<\'foo\' | \'bar\', unknown>`';
+
+type KeyedResult = Keyed;
+//=> '❌ `{}` is NOT assignable to `Record<\'foo\' | \'bar\', unknown>`'
+```
+
+Using a [mapped type](https://www.typescriptlang.org/docs/handbook/2/mapped-types.html#further-exploration), you can then check for each `KeyType` of `ObjectType`...
+
+```
+type OmitIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType // Map each key of `ObjectType`...
+	]: ObjectType[KeyType]; // ...to its original value, i.e. `OmitIndexSignature<Foo> == Foo`.
+};
+```
+
+...whether an empty object (`{}`) would be assignable to an object with that `KeyType` (`Record<KeyType, unknown>`)...
+
+```
+type OmitIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType
+	// Is `{}` assignable to `Record<KeyType, unknown>`?
+	as {} extends Record<KeyType, unknown>
+		? never // ✅ `{}` is assignable to `Record<KeyType, unknown>`
+		: KeyType // ❌ `{}` is NOT assignable to `Record<KeyType, unknown>`
+	]: ObjectType[KeyType];
+};
+```
+
+If `{}` is assignable, it means that `KeyType` is an index signature and we want to remove it. If it is not assignable, `KeyType` is a "real" key and we want to keep it.
+
+@example
+```
+import type {OmitIndexSignature} from 'type-fest';
+
+type Example = {
+	// These index signatures will be removed.
+	[x: string]: any;
+	[x: number]: any;
+	[x: symbol]: any;
+	[x: `head-${string}`]: string;
+	[x: `${string}-tail`]: string;
+	[x: `head-${string}-tail`]: string;
+	[x: `${bigint}`]: string;
+	[x: `embedded-${number}`]: string;
+
+	// These explicitly defined keys will remain.
+	foo: 'bar';
+	qux?: 'baz';
+};
+
+type ExampleWithoutIndexSignatures = OmitIndexSignature<Example>;
+//=> {foo: 'bar'; qux?: 'baz'}
+```
+
+@see {@link PickIndexSignature}
+@category Object
+*/
+type OmitIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? never : KeyType]: ObjectType[KeyType]; };
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.10.0/node_modules/type-fest/source/pick-index-signature.d.ts
+/**
+Pick only index signatures from the given object type, leaving out all explicitly defined properties.
+
+This is the counterpart of `OmitIndexSignature`.
+
+@example
+```
+import type {PickIndexSignature} from 'type-fest';
+
+declare const symbolKey: unique symbol;
+
+type Example = {
+	// These index signatures will remain.
+	[x: string]: unknown;
+	[x: number]: unknown;
+	[x: symbol]: unknown;
+	[x: `head-${string}`]: string;
+	[x: `${string}-tail`]: string;
+	[x: `head-${string}-tail`]: string;
+	[x: `${bigint}`]: string;
+	[x: `embedded-${number}`]: string;
+
+	// These explicitly defined keys will be removed.
+	['kebab-case-key']: string;
+	[symbolKey]: string;
+	foo: 'bar';
+	qux?: 'baz';
+};
+
+type ExampleIndexSignature = PickIndexSignature<Example>;
+// {
+// 	[x: string]: unknown;
+// 	[x: number]: unknown;
+// 	[x: symbol]: unknown;
+// 	[x: `head-${string}`]: string;
+// 	[x: `${string}-tail`]: string;
+// 	[x: `head-${string}-tail`]: string;
+// 	[x: `${bigint}`]: string;
+// 	[x: `embedded-${number}`]: string;
+// }
+```
+
+@see {@link OmitIndexSignature}
+@category Object
+*/
+type PickIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? KeyType : never]: ObjectType[KeyType]; };
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.10.0/node_modules/type-fest/source/merge.d.ts
+// Merges two objects without worrying about index signatures.
+type SimpleMerge<Destination, Source> = Simplify<{ [Key in keyof Destination as Key extends keyof Source ? never : Key]: Destination[Key]; } & Source>;
+/**
+Merge two types into a new type. Keys of the second type overrides keys of the first type.
+
+This is different from the TypeScript `&` (intersection) operator. With `&`, conflicting property types are intersected, which often results in `never`. For example, `{a: string} & {a: number}` makes `a` become `string & number`, which resolves to `never`. With `Merge`, the second type's keys cleanly override the first, so `Merge<{a: string}, {a: number}>` gives `{a: number}` as expected. `Merge` also produces a flattened type (via `Simplify`), making it more readable in IDE tooltips compared to `A & B`.
+
+@example
+```
+import type {Merge} from 'type-fest';
+
+type Foo = {
+	a: string;
+	b: number;
+};
+
+type Bar = {
+	a: number; // Conflicts with Foo['a']
+	c: boolean;
+};
+
+// With `&`, `a` becomes `string & number` which is `never`. Not what you want.
+type WithIntersection = (Foo & Bar)['a'];
+//=> never
+
+// With `Merge`, `a` is cleanly overridden to `number`.
+type WithMerge = Merge<Foo, Bar>['a'];
+//=> number
+```
+
+@example
+```
+import type {Merge} from 'type-fest';
+
+type Foo = {
+	[x: string]: unknown;
+	[x: number]: unknown;
+	foo: string;
+	bar: symbol;
+};
+
+type Bar = {
+	[x: number]: number;
+	[x: symbol]: unknown;
+	bar: Date;
+	baz: boolean;
+};
+
+export type FooBar = Merge<Foo, Bar>;
+//=> {
+// 	[x: string]: unknown;
+// 	[x: number]: number;
+// 	[x: symbol]: unknown;
+// 	foo: string;
+// 	bar: Date;
+// 	baz: boolean;
+// }
+```
+
+Note: If you want a merge type that more accurately reflects the runtime behavior of object spread or `Object.assign`, refer to the {@link ObjectMerge} type.
+
+@see {@link ObjectMerge}
+@category Object
+*/
+type Merge<Destination, Source> = Destination extends unknown // For distributing `Destination`
+ ? Source extends unknown // For distributing `Source`
+ ? If<IsEqual<Destination, Source>, Destination, _Merge<Destination, Source>> : never // Should never happen
+ : never; // Should never happen
+type _Merge<Destination, Source> = Simplify<SimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>> & SimpleMerge<OmitIndexSignature<Destination>, OmitIndexSignature<Source>>>;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.10.0/node_modules/type-fest/source/internal/object.d.ts
+/**
+Merges user specified options with default options.
+
+@example
+```
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};
+type SpecifiedOptions = {leavesOnly: true};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//=> {maxRecursionDepth: 10; leavesOnly: true}
+```
+
+@example
+```
+// Complains if default values are not provided for optional options
+
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10};
+type SpecifiedOptions = {};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//                                              ~~~~~~~~~~~~~~~~~~~
+// Property 'leavesOnly' is missing in type 'DefaultPathsOptions' but required in type '{ maxRecursionDepth: number; leavesOnly: boolean; }'.
+```
+
+@example
+```
+// Complains if an option's default type does not conform to the expected type
+
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: 'no'};
+type SpecifiedOptions = {};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//                                              ~~~~~~~~~~~~~~~~~~~
+// Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
+```
+
+@example
+```
+// Complains if an option's specified type does not conform to the expected type
+
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};
+type SpecifiedOptions = {leavesOnly: 'yes'};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//                                                                   ~~~~~~~~~~~~~~~~
+// Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
+```
+*/
+type ApplyDefaultOptions<Options extends object, Defaults extends Simplify<Omit<Required<Options>, RequiredKeysOf<Options>> & Partial<Record<RequiredKeysOf<Options>, never>>>, SpecifiedOptions extends Options> = _ApplyDefaultOptions<Options, Defaults, SpecifiedOptions> extends (infer Result extends Required<Options> // `extends Required<Options>` ensures that `ApplyDefaultOptions<SomeOption, ...>` is always assignable to `Required<SomeOption>`
+) ? Result : never;
+type _ApplyDefaultOptions<Options, Defaults, SpecifiedOptions> = If<IsAny<SpecifiedOptions>, Defaults, If<IsNever<SpecifiedOptions>, Defaults, Merge<Defaults, { [Key in keyof SpecifiedOptions as undefined extends Required<Options>[Key & keyof Options] ? Key : undefined extends SpecifiedOptions[Key] ? never : Key]: SpecifiedOptions[Key]; }>>>;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.10.0/node_modules/type-fest/source/except.d.ts
+/**
+Filter out keys from an object.
+
+Returns `never` if `Exclude` is strictly equal to `Key`.
+Returns `never` if `Key` extends `Exclude`.
+Returns `Key` otherwise.
+
+@example
+```
+type Filtered = Filter<'foo', 'foo'>;
+//=> never
+```
+
+@example
+```
+type Filtered = Filter<'bar', string>;
+//=> never
+```
+
+@example
+```
+type Filtered = Filter<'bar', 'foo'>;
+//=> 'bar'
+```
+
+@see {Except}
+*/
+type Filter<KeyType, ExcludeType> = IsEqual<KeyType, ExcludeType> extends true ? never : (KeyType extends ExcludeType ? never : KeyType);
+type ExceptOptions = {
+  /**
+	Disallow assigning non-specified properties.
+
+	Note that any omitted properties in the resulting type will be present in autocomplete as `undefined`.
+
+	@default false
+	*/
+  requireExactProps?: boolean;
+};
+type DefaultExceptOptions = {
+  requireExactProps: false;
+};
+/**
+Create a type from an object type without certain keys.
+
+We recommend setting the `requireExactProps` option to `true`.
+
+This type is a stricter version of [`Omit`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-5.html#the-omit-helper-type). The `Omit` type does not restrict the omitted keys to be keys present on the given type, while `Except` does. The benefits of a stricter type are avoiding typos and allowing the compiler to pick up on rename refactors automatically.
+
+This type was proposed to the TypeScript team, which declined it, saying they prefer that libraries implement stricter versions of the built-in types ([microsoft/TypeScript#30825](https://github.com/microsoft/TypeScript/issues/30825#issuecomment-523668235)).
+
+@example
+```
+import type {Except} from 'type-fest';
+
+type Foo = {
+	a: number;
+	b: string;
+};
+
+type FooWithoutA = Except<Foo, 'a'>;
+//=> {b: string}
+
+// @ts-expect-error
+const fooWithoutA: FooWithoutA = {a: 1, b: '2'};
+// errors: 'a' does not exist in type '{ b: string; }'
+
+type FooWithoutB = Except<Foo, 'b', {requireExactProps: true}>;
+//=> {a: number} & Partial<Record<'b', never>>
+
+// @ts-expect-error
+const fooWithoutB: FooWithoutB = {a: 1, b: '2'};
+// errors at 'b': Type 'string' is not assignable to type 'undefined'.
+
+// The `Omit` utility type doesn't work when omitting specific keys from objects containing index signatures.
+
+// Consider the following example:
+
+type UserData = {
+	[metadata: string]: string;
+	email: string;
+	name: string;
+	role: 'admin' | 'user';
+};
+
+// `Omit` clearly doesn't behave as expected in this case:
+type PostPayload = Omit<UserData, 'email'>;
+//=> {[x: string]: string; [x: number]: string}
+
+// In situations like this, `Except` works better.
+// It simply removes the `email` key while preserving all the other keys.
+type PostPayloadFixed = Except<UserData, 'email'>;
+//=> {[x: string]: string; name: string; role: 'admin' | 'user'}
+```
+
+@category Object
+*/
+type Except<ObjectType, KeysType extends keyof ObjectType, Options extends ExceptOptions = {}> = _Except<ObjectType, KeysType, ApplyDefaultOptions<ExceptOptions, DefaultExceptOptions, Options>>;
+type _Except<ObjectType, KeysType extends keyof ObjectType, Options extends Required<ExceptOptions>> = { [KeyType in keyof ObjectType as Filter<KeyType, KeysType>]: ObjectType[KeyType]; } & (Options['requireExactProps'] extends true ? Partial<Record<KeysType, never>> : {});
+//#endregion
+//#region src/models/container/MockBlobClient.d.ts
+export declare class MockBlobClient implements Except<BlobClient, "accountName"> {
+  connectionString: string;
+  containerName: string;
+  credential: AnonymousCredential;
+  name: string;
+  url: string;
+  get container(): MapValue<typeof MockContainerDatabase>;
+  constructor(connectionString: string, containerName: string, blobName: string);
+  abortCopyFromURL(): Promise<BlobAbortCopyFromURLResponse>;
+  beginCopyFromURL(copySource: string): Promise<PollerLikeWithCancellation<PollOperationState<BlobBeginCopyFromURLResponse>, BlobBeginCopyFromURLResponse>>;
+  createSnapshot(): Promise<BlobCreateSnapshotResponse>;
+  delete(): Promise<BlobDeleteResponse>;
+  deleteIfExists(): Promise<BlobDeleteIfExistsResponse>;
+  deleteImmutabilityPolicy(): Promise<BlobDeleteImmutabilityPolicyResponse>;
+  download(): Promise<BlobDownloadResponseParsed>;
+  downloadToBuffer(): Promise<Buffer>;
+  downloadToFile(): Promise<BlobDownloadResponseParsed>;
+  exists(): Promise<boolean>;
+  generateSasStringToSign(): string;
+  generateSasUrl(options: BlobGenerateSasUrlOptions): Promise<string>;
+  generateUserDelegationSasStringToSign(): string;
+  generateUserDelegationSasUrl(): Promise<string>;
+  getAccountInfo(): Promise<BlobGetAccountInfoResponse>;
+  getAppendBlobClient(): AppendBlobClient;
+  getBlobLeaseClient(): BlobLeaseClient;
+  getBlockBlobClient(): BlockBlobClient;
+  getPageBlobClient(): PageBlobClient;
+  getProperties(): Promise<BlobGetPropertiesResponse>;
+  getTags(): Promise<BlobGetTagsResponse>;
+  setAccessTier(): Promise<BlobSetTierResponse>;
+  setHTTPHeaders(): Promise<BlobSetHTTPHeadersResponse>;
+  setImmutabilityPolicy(): Promise<BlobSetImmutabilityPolicyResponse>;
+  setLegalHold(): Promise<BlobSetLegalHoldResponse>;
+  setMetadata(metadata?: Metadata): Promise<BlobSetMetadataResponse>;
+  setTags(): Promise<BlobSetTagsResponse>;
+  syncCopyFromURL(): Promise<BlobCopyFromURLResponse>;
+  undelete(): Promise<BlobUndeleteResponse>;
+  withSnapshot(): BlockBlobClient;
+  withVersion(): BlobClient;
+}
+//#endregion
+//#region src/models/container/MockBlobDates.d.ts
+export interface MockBlobDates {
+  createdOn: Date;
+  etag: string;
+  lastModified: Date;
+}
+//#endregion
+//#region src/models/container/MockBlockBlobClient.d.ts
+export declare class MockBlockBlobClient extends MockBlobClient implements Except<BlockBlobClient, "accountName"> {
+  commitBlockList(): Promise<BlockBlobCommitBlockListResponse>;
+  getBlockList(): Promise<BlockBlobGetBlockListResponse>;
+  query(): Promise<BlobDownloadResponseModel>;
+  stageBlock(): Promise<BlockBlobStageBlockResponse>;
+  stageBlockFromURL(): Promise<BlockBlobStageBlockFromURLResponse>;
+  syncUploadFromURL(): Promise<BlockBlobPutBlobFromUrlResponse>;
+  upload(body: HttpRequestBody, _contentLength: number, options?: BlockBlobUploadOptions): Promise<BlockBlobUploadResponse>;
+  uploadBrowserData(): Promise<BlobUploadCommonResponse>;
+  uploadData(): Promise<BlobUploadCommonResponse>;
+  uploadFile(): Promise<BlobUploadCommonResponse>;
+  uploadStream(): Promise<BlobUploadCommonResponse>;
+}
+//#endregion
+//#region src/models/shared/PageSettings.d.ts
+/**
+ * An interface that tracks the settings for paged iteration
+ */
+export interface PageSettings {
+  /**
+   * The token that keeps track of where to continue the iterator
+   */
+  continuationToken?: string;
+  /**
+   * The size of the page during paged iteration
+   */
+  maxPageSize?: number;
+}
+//#endregion
+//#region src/models/shared/PagedAsyncIterableIterator.d.ts
+/**
+ * An interface that allows async iterable iteration both to completion and by page.
+ */
+export interface PagedAsyncIterableIterator<TElement, TPage = TElement[], TPageSettings = PageSettings> {
+  /**
+   * The connection to the async iterator, part of the iteration protocol
+   */
+  [Symbol.asyncIterator]: () => PagedAsyncIterableIterator<TElement, TPage, TPageSettings>;
+  /**
+   * Return an AsyncIterableIterator that works a page at a time
+   */
+  byPage: (settings?: TPageSettings) => AsyncIterableIterator<TPage>;
+  /**
+   * The next method, part of the iteration protocol
+   */
+  next: () => Promise<IteratorResult<TElement>>;
+}
+//#endregion
+//#region src/models/container/MockContainerClient.d.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();
+ */
+export declare class MockContainerClient implements Except<ContainerClient, "accountName"> {
+  #private;
+  connectionString: string;
+  containerName: string;
+  credential: AnonymousCredential;
+  url: string;
+  get container(): MapValue<typeof MockContainerDatabase>;
+  constructor(connectionString: string, containerName: string);
+  create(): Promise<ContainerCreateResponse>;
+  createIfNotExists(): Promise<ContainerCreateIfNotExistsResponse>;
+  delete(): Promise<ContainerDeleteResponse>;
+  deleteBlob(blobName: string): Promise<BlobDeleteResponse>;
+  deleteIfExists(): Promise<ContainerDeleteIfExistsResponse>;
+  exists(): Promise<boolean>;
+  findBlobsByTags(): PagedAsyncIterableIterator<FilterBlobItem, ContainerFindBlobsByTagsSegmentResponse>;
+  generateSasStringToSign(): string;
+  generateSasUrl(options: ContainerGenerateSasUrlOptions): Promise<string>;
+  generateUserDelegationSasStringToSign(): string;
+  generateUserDelegationSasUrl(): Promise<string>;
+  getAccessPolicy(): Promise<ContainerGetAccessPolicyResponse>;
+  getAccountInfo(): Promise<ContainerGetAccountInfoResponse>;
+  getAppendBlobClient(): AppendBlobClient;
+  getBlobBatchClient(): BlobBatchClient;
+  getBlobClient(blobName: string): BlobClient;
+  getBlobLeaseClient(): BlobLeaseClient;
+  getBlockBlobClient(blobName: string): BlockBlobClient;
+  getPageBlobClient(): PageBlobClient;
+  getProperties(): Promise<ContainerGetPropertiesResponse>;
+  listBlobsByHierarchy(delimiter: string, options?: ContainerListBlobsOptions): PagedAsyncIterableIterator<BlobHierarchyItem, ContainerListBlobHierarchySegmentResponse>;
+  listBlobsFlat(options?: ContainerListBlobsOptions): PagedAsyncIterableIterator<BlobItem, ContainerListBlobFlatSegmentResponse>;
+  setAccessPolicy(): Promise<ContainerSetAccessPolicyResponse>;
+  setMetadata(): Promise<ContainerSetMetadataResponse>;
+  uploadBlockBlob(blobName: string, body: HttpRequestBody, contentLength: number): Promise<{
+    blockBlobClient: BlockBlobClient;
+    response: BlockBlobUploadResponse;
+  }>;
+}
+//#endregion
+//#region src/models/eventGrid/MockEventGridPublisherClient.d.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.
+ */
+export declare class MockEventGridPublisherClient implements Except<EventGridPublisherClient<"EventGrid">, "apiVersion"> {
+  readonly endpointUrl: string;
+  readonly inputSchema: "EventGrid";
+  readonly topicType: "EventGrid";
+  constructor(endpoint: string, topicType: "EventGrid");
+  send(newEvents: EventGridEvent<unknown>[]): Promise<void>;
+}
+//#endregion
+//#region src/store/MockQueueDatabase.d.ts
+export declare const MockQueueDatabase: Map<string, string[]>;
+//#endregion
+//#region src/models/queue/MockQueueClient.d.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();
+ */
+export declare class MockQueueClient implements Except<QueueClient, "accountName"> {
+  connectionString: string;
+  name: string;
+  url: string;
+  get queue(): MapValue<typeof MockQueueDatabase>;
+  constructor(connectionString: string, queueName: string);
+  clearMessages(): Promise<QueueClearMessagesResponse>;
+  create(_options?: QueueCreateOptions): Promise<QueueCreateResponse>;
+  createIfNotExists(): Promise<QueueCreateIfNotExistsResponse>;
+  delete(): Promise<QueueDeleteResponse>;
+  deleteIfExists(): Promise<QueueDeleteIfExistsResponse>;
+  deleteMessage(): Promise<QueueDeleteMessageResponse>;
+  exists(): Promise<boolean>;
+  generateSasStringToSign(): string;
+  generateSasUrl(options: QueueGenerateSasUrlOptions): string;
+  generateUserDelegationSasUrl(): string;
+  generateUserDelegationStringToSign(): string;
+  getAccessPolicy(): Promise<QueueGetAccessPolicyResponse>;
+  getProperties(): Promise<QueueGetPropertiesResponse>;
+  getServiceProperties(): Promise<QueueServiceProperties>;
+  listQueues(): AsyncIterableIterator<QueueItem>;
+  peekMessages(_options?: QueuePeekMessagesOptions): Promise<QueuePeekMessagesResponse>;
+  receiveMessages(_options?: QueueReceiveMessageOptions): Promise<QueueReceiveMessageResponse>;
+  sendMessage(messageText: string, _options?: QueueSendMessageOptions): Promise<QueueSendMessageResponse>;
+  setAccessPolicy(_identifiers?: SignedIdentifier[]): Promise<QueueSetAccessPolicyResponse>;
+  setMetadata(): Promise<QueueSetMetadataResponse>;
+  updateMessage(): Promise<QueueUpdateMessageResponse>;
+}
+//#endregion
+//#region src/store/MockSearchDatabase.d.ts
+export declare const MockSearchDatabase: Map<string, object[]>;
+//#endregion
+//#region src/models/search/MockSearchClient.d.ts
+/**
+ * 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 });
+ */
+export declare class MockSearchClient<TModel extends object = Record<string, unknown>> implements Except<SearchClient<TModel>, "pipeline"> {
+  readonly apiVersion: string;
+  readonly endpoint: string;
+  readonly indexName: string;
+  readonly serviceVersion: string;
+  get documents(): MapValue<typeof MockSearchDatabase>;
+  constructor(indexName: string);
+  autocomplete(): Promise<AutocompleteResult>;
+  deleteDocuments(documents: TModel[], options?: DeleteDocumentsOptions): Promise<IndexDocumentsResult>;
+  deleteDocuments(keyName: keyof TModel, keyValues: string[], options?: DeleteDocumentsOptions): Promise<IndexDocumentsResult>;
+  getDocument<TFields extends SelectFields<TModel>>(_key: string, _options?: GetDocumentOptions<TModel, TFields>): Promise<NarrowedModel<TModel, TFields>>;
+  getDocumentsCount(_options?: CountDocumentsOptions): Promise<number>;
+  indexDocuments(_batch: IndexDocumentsBatch<TModel>, _options?: IndexDocumentsOptions): Promise<IndexDocumentsResult>;
+  mergeDocuments(_documents: TModel[], _options?: MergeDocumentsOptions): Promise<IndexDocumentsResult>;
+  mergeOrUploadDocuments(_documents: TModel[], _options?: MergeOrUploadDocumentsOptions): Promise<IndexDocumentsResult>;
+  search<TFields extends SelectFields<TModel>>(searchText?: string, options?: SearchOptions<TModel, TFields>): Promise<SearchDocumentsResult<TModel, TFields>>;
+  suggest<TFields extends SelectFields<TModel> = never>(_searchText: string, _suggesterName: string, _options?: SuggestOptions<TModel, TFields>): Promise<SuggestDocumentsResult<TModel, TFields>>;
+  uploadDocuments(documents: TModel[], _options?: UploadDocumentsOptions): Promise<IndexDocumentsResult>;
+}
+//#endregion
+//#region src/store/MockServiceBusDatabase.d.ts
+export declare const MockServiceBusDatabase: Map<string, ServiceBusMessage[]>;
+//#endregion
+//#region src/models/serviceBus/MockServiceBusSender.d.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());
+ */
+export declare class MockServiceBusSender implements ServiceBusSender {
+  entityPath: string;
+  identifier: string;
+  isClosed: boolean;
+  get queue(): MapValue<typeof MockServiceBusDatabase>;
+  constructor(queueName: string);
+  cancelScheduledMessages(): Promise<void>;
+  close(): Promise<void>;
+  createMessageBatch(): Promise<ServiceBusMessageBatch>;
+  scheduleMessages(messages: ServiceBusMessage | ServiceBusMessage[], scheduledEnqueueTimeUtc: Date): Promise<never[]>;
+  sendMessages(messages: ServiceBusMessage | ServiceBusMessage[] | ServiceBusMessageBatch): Promise<void>;
+}
+//#endregion
+//#region src/models/shared/MockResponse.d.ts
+export interface MockResponse {
+  headers: HttpHeadersLike;
+  parsedHeaders: Record<string, never>;
+  request: WebResourceLike;
+  status: number;
+}
+//#endregion
+//#region src/models/shared/MockRestError.d.ts
+export declare class MockRestError extends RestError {
+  constructor(message: string, statusCode: number);
+}
+//#endregion
+//#region src/models/shared/NotImplementedError.d.ts
+export declare class NotImplementedError extends Error {
+  constructor(name: string);
+}
+//#endregion
+//#region src/store/MockTableDatabase.d.ts
+export declare const MockTableDatabase: Map<string, Map<string, TableEntity>>;
+//#endregion
+//#region src/models/table/MockTableClient.d.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");
+ */
+export declare class MockTableClient<TEntity extends TableEntity = TableEntity> implements Except<TableClient, "pipeline"> {
+  #private;
+  entityType: TEntity;
+  tableName: string;
+  url: string;
+  get table(): MapValue<typeof MockTableDatabase>;
+  constructor(_url: string, tableName: string);
+  createEntity<T extends object>(entity: TableEntity<T>): Promise<CreateTableEntityResponse>;
+  createTable(): Promise<void>;
+  deleteEntity(partitionKey: string, rowKey: string, options?: {
+    etag?: string;
+  }): Promise<TableDeleteEntityHeaders>;
+  deleteTable(): Promise<void>;
+  getAccessPolicy(): Promise<GetAccessPolicyResponse>;
+  getEntity<T extends object = Record<string, unknown>>(partitionKey: string, rowKey: string): Promise<GetTableEntityResponse<TableEntityResult<T>>>;
+  listEntities<T extends object>(options?: ListTableEntitiesOptions): PagedAsyncIterableIterator<TableEntityResult<T>, TableEntityResultPage<T>>;
+  setAccessPolicy(): Promise<TableSetAccessPolicyHeaders>;
+  submitTransaction(actions: Parameters<TableClient["submitTransaction"]>[0]): Promise<TableTransactionResponse>;
+  updateEntity<T extends object>(entity: TableEntity<T>, mode?: UpdateMode, options?: {
+    etag?: string;
+  }): Promise<TableMergeEntityHeaders>;
+  upsertEntity<T extends object>(entity: TableEntity<T>, mode?: UpdateMode): Promise<TableMergeEntityHeaders>;
+}
+//#endregion
+//#region src/models/webPubSub/MockWebPubSubServiceClient.d.ts
+/**
+ * A minimal mock of the Azure WebPubSubServiceClient for testing purposes.
+ * Only implements `group().sendToAll` — the only method used in azure-functions tests.
+ */
+export declare class MockWebPubSubServiceClient {
+  group(_groupName: string): {
+    sendToAll: () => Promise<void>;
+  };
+}
+//#endregion
+//#region src/services/container/bodyToBuffer.d.ts
+export declare const bodyToBuffer: (body: HttpRequestBody) => Promise<Buffer>;
+//#endregion
+//#region src/services/container/checkIsReadableStream.d.ts
+export declare const checkIsReadableStream: (value: unknown) => value is NodeJS.ReadableStream;
+//#endregion
+//#region src/services/container/constants.d.ts
+export declare const MOCK_BLOB_SEEDED_DATE: Date;
+export declare const MOCK_BLOB_SEEDED_PROPERTIES: MockBlobDates;
+//#endregion
+//#region src/services/container/deleteMockBlob.d.ts
+export declare const deleteMockBlob: (containerName: string, blobName: string) => boolean;
+//#endregion
+//#region src/services/container/getAzureErrorXml.d.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.
+ */
+export declare const getAzureErrorXml: (errorCode: string, errorMessage: string) => string;
+//#endregion
+//#region src/services/container/getBlobItemXml.d.ts
+export declare const getBlobItemXml: ({ name, properties }: BlobItem) => string;
+//#endregion
+//#region src/services/container/getBlobPrefixXml.d.ts
+export declare const getBlobPrefixXml: (name: string) => string;
+//#endregion
+//#region src/services/container/getBlobUrl.d.ts
+export declare const getBlobUrl: (containerName: string, blobName: string) => string;
+//#endregion
+//#region src/services/container/getBlobUrlParts.d.ts
+export declare const getBlobUrlParts: (url: string) => undefined | {
+  blobName: string;
+  containerName: string;
+};
+//#endregion
+//#region src/services/container/getListBlobsSegmentResponse.d.ts
+export declare const getListBlobsSegmentResponse: (containerName: string, prefix: string, segment: BlobHierarchyListSegment, blobsXml: string) => ContainerListBlobHierarchySegmentResponse;
+//#endregion
+//#region src/services/container/getListBlobsXml.d.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.
+ */
+export declare const getListBlobsXml: (containerName: string, blobsXml: string) => string;
+//#endregion
+//#region src/services/container/getMockBlobKey.d.ts
+export declare const getMockBlobKey: (containerName: string, blobName: string) => string;
+//#endregion
+//#region src/services/container/getMockContainer.d.ts
+export declare const getMockContainer: (containerName: string) => MapValue<typeof MockContainerDatabase>;
+//#endregion
+//#region src/services/container/readMockBlobDates.d.ts
+export declare const readMockBlobDates: (containerName: string, blobName: string) => MockBlobDates;
+//#endregion
+//#region src/services/container/readMockBlobMetadata.d.ts
+export declare const readMockBlobMetadata: (containerName: string, blobName: string) => Record<string, string> | undefined;
+//#endregion
+//#region src/services/container/storeMockBlobMetadata.d.ts
+export declare const storeMockBlobMetadata: (containerName: string, blobName: string, metadata: Record<string, string> | undefined) => void;
+//#endregion
+//#region src/services/container/storeMockBlobWrite.d.ts
+export declare const storeMockBlobWrite: (containerName: string, blobName: string, isExisting: boolean) => void;
+//#endregion
+//#region src/services/container/toWebResourceLike.d.ts
+export declare const toWebResourceLike: (request: PipelineRequest) => WebResourceLike;
+//#endregion
+//#region src/services/filter/applyFilter.d.ts
+export declare const applyFilter: <T extends Record<string, unknown>>(documents: T[], clauses: Clause<T>[]) => T[];
+//#endregion
+//#region src/services/filter/checkIsNullClause.d.ts
+export declare const checkIsNullClause: (clause: Clause<Record<string, unknown>>) => boolean;
+//#endregion
+//#region src/services/filter/compare.d.ts
+export declare const compare: <T>(operator: BinaryOperator, leftHandSide: T, rightHandSide: null | T) => boolean;
+//#endregion
+//#region src/services/filter/createFilterPredicate.d.ts
+export declare const createFilterPredicate: (filter: string) => ((document: Record<string, unknown>) => boolean);
+//#endregion
+//#region src/services/queue/getMockQueueMessageItem.d.ts
+export declare const getMockQueueMessageItem: (messageText: string) => {
+  expiresOn: Date;
+  insertedOn: Date;
+  messageId: string;
+  messageText: string;
+};
+//#endregion
+//#region src/services/shared/createMockResponse.d.ts
+export declare const createMockResponse: (status: number, url?: string) => MockResponse;
+//#endregion
+//#region src/services/shared/getMockSasUrl.d.ts
+export declare const getMockSasUrl: (url: string, permissions: undefined | {
+  toString: () => string;
+}, resourceType?: string) => string;
+//#endregion
+//#region src/services/table/compareByCompositeKey.d.ts
+export declare const compareByCompositeKey: (firstEntity: TableEntity, secondEntity: TableEntity) => number;
+//#endregion
+//#region src/store/MockContainerBlobDatesDatabase.d.ts
+export declare const MockContainerBlobDatesDatabase: Map<string, MockBlobDates>;
+//#endregion
+//#region src/store/MockContainerBlobMetadataDatabase.d.ts
+export declare const MockContainerBlobMetadataDatabase: Map<string, Record<string, string>>;
+//#endregion
+//#region src/store/MockEventGridDatabase.d.ts
+export declare const MockEventGridDatabase: Map<string, EventGridEvent<unknown>[]>;
+//#endregion
+export {};