@wix/crm 1.0.131 → 1.0.133

package/type-bundles/context.bundle.d.ts

@@ -1,39 +1,131 @@
-type RESTFunctionDescriptor<T extends (...args: any[]) => any = (...args: any[]) => any> = (httpClient: HttpClient) => T;
-interface HttpClient {
-    request<TResponse, TData = any>(req: RequestOptionsFactory<TResponse, TData>): Promise<HttpResponse<TResponse>>;
+type HostModule$5<T, H extends Host$5> = {
+    __type: 'host';
+    create(host: H): T;
+};
+type HostModuleAPI$5<T extends HostModule$5<any, any>> = T extends HostModule$5<infer U, any> ? U : never;
+type Host$5<Environment = unknown> = {
+    channel: {
+        observeState(callback: (props: unknown, environment: Environment) => unknown): {
+            disconnect: () => void;
+        } | Promise<{
+            disconnect: () => void;
+        }>;
+    };
+    environment?: Environment;
+    /**
+     * Optional name of the environment, use for logging
+     */
+    name?: string;
+    /**
+     * Optional bast url to use for API requests, for example `www.wixapis.com`
+     */
+    apiBaseUrl?: string;
+    /**
+     * Possible data to be provided by every host, for cross cutting concerns
+     * like internationalization, billing, etc.
+     */
+    essentials?: {
+        /**
+         * The language of the currently viewed session
+         */
+        language?: string;
+        /**
+         * The locale of the currently viewed session
+         */
+        locale?: string;
+        /**
+         * Any headers that should be passed through to the API requests
+         */
+        passThroughHeaders?: Record<string, string>;
+    };
+};
+
+type RESTFunctionDescriptor$5<T extends (...args: any[]) => any = (...args: any[]) => any> = (httpClient: HttpClient$5) => T;
+interface HttpClient$5 {
+    request<TResponse, TData = any>(req: RequestOptionsFactory$5<TResponse, TData>): Promise<HttpResponse$5<TResponse>>;
     fetchWithAuth: typeof fetch;
     wixAPIFetch: (relativeUrl: string, options: RequestInit) => Promise<Response>;
+    getActiveToken?: () => string | undefined;
 }
-type RequestOptionsFactory<TResponse = any, TData = any> = (context: any) => RequestOptions<TResponse, TData>;
-type HttpResponse<T = any> = {
+type RequestOptionsFactory$5<TResponse = any, TData = any> = (context: any) => RequestOptions$5<TResponse, TData>;
+type HttpResponse$5<T = any> = {
     data: T;
     status: number;
     statusText: string;
     headers: any;
     request?: any;
 };
-type RequestOptions<_TResponse = any, Data = any> = {
+type RequestOptions$5<_TResponse = any, Data = any> = {
     method: 'POST' | 'GET' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
     url: string;
     data?: Data;
     params?: URLSearchParams;
-} & APIMetadata;
-type APIMetadata = {
+} & APIMetadata$5;
+type APIMetadata$5 = {
     methodFqn?: string;
     entityFqdn?: string;
     packageName?: string;
 };
-type BuildRESTFunction<T extends RESTFunctionDescriptor> = T extends RESTFunctionDescriptor<infer U> ? U : never;
-type EventDefinition<Payload = unknown, Type extends string = string> = {
+type BuildRESTFunction$5<T extends RESTFunctionDescriptor$5> = T extends RESTFunctionDescriptor$5<infer U> ? U : never;
+type EventDefinition$5<Payload = unknown, Type extends string = string> = {
     __type: 'event-definition';
     type: Type;
     isDomainEvent?: boolean;
     transformations?: (envelope: unknown) => Payload;
     __payload: Payload;
 };
-declare function EventDefinition<Type extends string>(type: Type, isDomainEvent?: boolean, transformations?: (envelope: any) => unknown): <Payload = unknown>() => EventDefinition<Payload, Type>;
-type EventHandler<T extends EventDefinition> = (payload: T['__payload']) => void | Promise<void>;
-type BuildEventDefinition<T extends EventDefinition<any, string>> = (handler: EventHandler<T>) => void;
+declare function EventDefinition$5<Type extends string>(type: Type, isDomainEvent?: boolean, transformations?: (envelope: any) => unknown): <Payload = unknown>() => EventDefinition$5<Payload, Type>;
+type EventHandler$5<T extends EventDefinition$5> = (payload: T['__payload']) => void | Promise<void>;
+type BuildEventDefinition$5<T extends EventDefinition$5<any, string>> = (handler: EventHandler$5<T>) => void;
+
+type ServicePluginMethodInput$5 = {
+    request: any;
+    metadata: any;
+};
+type ServicePluginContract$5 = Record<string, (payload: ServicePluginMethodInput$5) => unknown | Promise<unknown>>;
+type ServicePluginMethodMetadata$5 = {
+    name: string;
+    primaryHttpMappingPath: string;
+    transformations: {
+        fromREST: (...args: unknown[]) => ServicePluginMethodInput$5;
+        toREST: (...args: unknown[]) => unknown;
+    };
+};
+type ServicePluginDefinition$5<Contract extends ServicePluginContract$5> = {
+    __type: 'service-plugin-definition';
+    componentType: string;
+    methods: ServicePluginMethodMetadata$5[];
+    __contract: Contract;
+};
+declare function ServicePluginDefinition$5<Contract extends ServicePluginContract$5>(componentType: string, methods: ServicePluginMethodMetadata$5[]): ServicePluginDefinition$5<Contract>;
+type BuildServicePluginDefinition$5<T extends ServicePluginDefinition$5<any>> = (implementation: T['__contract']) => void;
+declare const SERVICE_PLUGIN_ERROR_TYPE$5 = "wix_spi_error";
+
+type RequestContext$5 = {
+    isSSR: boolean;
+    host: string;
+    protocol?: string;
+};
+type ResponseTransformer$5 = (data: any, headers?: any) => any;
+/**
+ * Ambassador request options types are copied mostly from AxiosRequestConfig.
+ * They are copied and not imported to reduce the amount of dependencies (to reduce install time).
+ * https://github.com/axios/axios/blob/3f53eb6960f05a1f88409c4b731a40de595cb825/index.d.ts#L307-L315
+ */
+type Method$5 = 'get' | 'GET' | 'delete' | 'DELETE' | 'head' | 'HEAD' | 'options' | 'OPTIONS' | 'post' | 'POST' | 'put' | 'PUT' | 'patch' | 'PATCH' | 'purge' | 'PURGE' | 'link' | 'LINK' | 'unlink' | 'UNLINK';
+type AmbassadorRequestOptions$5<T = any> = {
+    _?: T;
+    url?: string;
+    method?: Method$5;
+    params?: any;
+    data?: any;
+    transformResponse?: ResponseTransformer$5 | ResponseTransformer$5[];
+};
+type AmbassadorFactory$5<Request, Response> = (payload: Request) => ((context: RequestContext$5) => AmbassadorRequestOptions$5<Response>) & {
+    __isAmbassador: boolean;
+};
+type AmbassadorFunctionDescriptor$5<Request = any, Response = any> = AmbassadorFactory$5<Request, Response>;
+type BuildAmbassadorFunction$5<T extends AmbassadorFunctionDescriptor$5> = T extends AmbassadorFunctionDescriptor$5<infer Request, infer Response> ? (req: Request) => Promise<Response> : never;
 
 declare global {
 	// eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
@@ -42,6 +134,348 @@ declare global {
 	}
 }
 
+declare const emptyObjectSymbol$5: unique symbol;
+
+/**
+Represents a strictly empty plain object, the `{}` value.
+
+When you annotate something as the type `{}`, it can be anything except `null` and `undefined`. This means that you cannot use `{}` to represent an empty plain object ([read more](https://stackoverflow.com/questions/47339869/typescript-empty-object-and-any-difference/52193484#52193484)).
+
+@example
+```
+import type {EmptyObject} from 'type-fest';
+
+// The following illustrates the problem with `{}`.
+const foo1: {} = {}; // Pass
+const foo2: {} = []; // Pass
+const foo3: {} = 42; // Pass
+const foo4: {} = {a: 1}; // Pass
+
+// With `EmptyObject` only the first case is valid.
+const bar1: EmptyObject = {}; // Pass
+const bar2: EmptyObject = 42; // Fail
+const bar3: EmptyObject = []; // Fail
+const bar4: EmptyObject = {a: 1}; // Fail
+```
+
+Unfortunately, `Record<string, never>`, `Record<keyof any, never>` and `Record<never, never>` do not work. See {@link https://github.com/sindresorhus/type-fest/issues/395 #395}.
+
+@category Object
+*/
+type EmptyObject$5 = {[emptyObjectSymbol$5]?: never};
+
+/**
+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$5<A, B> =
+	(<G>() => G extends A ? 1 : 2) extends
+	(<G>() => G extends B ? 1 : 2)
+		? true
+		: false;
+
+/**
+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$5<KeyType, ExcludeType> = IsEqual$5<KeyType, ExcludeType> extends true ? never : (KeyType extends ExcludeType ? never : KeyType);
+
+type ExceptOptions$5 = {
+	/**
+	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;
+};
+
+/**
+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}
+
+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>>
+
+const fooWithoutB: FooWithoutB = {a: 1, b: '2'};
+//=> errors at 'b': Type 'string' is not assignable to type 'undefined'.
+```
+
+@category Object
+*/
+type Except$5<ObjectType, KeysType extends keyof ObjectType, Options extends ExceptOptions$5 = {requireExactProps: false}> = {
+	[KeyType in keyof ObjectType as Filter$5<KeyType, KeysType>]: ObjectType[KeyType];
+} & (Options['requireExactProps'] extends true
+	? Partial<Record<KeysType, never>>
+	: {});
+
+/**
+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';
+
+// https://github.com/andnp/SimplyTyped/blob/master/src/types/strings.ts
+type AreStringsEqual<A extends string, B extends string> =
+	And<
+		IsNever<Exclude<A, B>> extends true ? true : false,
+		IsNever<Exclude<B, A>> extends true ? true : false
+	>;
+
+type EndIfEqual<I extends string, O extends string> =
+	AreStringsEqual<I, O> extends true
+		? never
+		: void;
+
+function endIfEqual<I extends string, O extends string>(input: I, output: O): EndIfEqual<I, O> {
+	if (input === output) {
+		process.exit(0);
+	}
+}
+
+endIfEqual('abc', 'abc');
+//=> never
+
+endIfEqual('abc', '123');
+//=> void
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsNever$5<T> = [T] extends [never] ? true : false;
+
+/**
+An if-else-like type that resolves depending on whether the given type is `never`.
+
+@see {@link IsNever}
+
+@example
+```
+import type {IfNever} from 'type-fest';
+
+type ShouldBeTrue = IfNever<never>;
+//=> true
+
+type ShouldBeBar = IfNever<'not never', 'foo', 'bar'>;
+//=> 'bar'
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IfNever$5<T, TypeIfNever = true, TypeIfNotNever = false> = (
+	IsNever$5<T> extends true ? TypeIfNever : TypeIfNotNever
+);
+
+/**
+Extract the keys from a type where the value type of the key extends the given `Condition`.
+
+Internally this is used for the `ConditionalPick` and `ConditionalExcept` types.
+
+@example
+```
+import type {ConditionalKeys} from 'type-fest';
+
+interface Example {
+	a: string;
+	b: string | number;
+	c?: string;
+	d: {};
+}
+
+type StringKeysOnly = ConditionalKeys<Example, string>;
+//=> 'a'
+```
+
+To support partial types, make sure your `Condition` is a union of undefined (for example, `string | undefined`) as demonstrated below.
+
+@example
+```
+import type {ConditionalKeys} from 'type-fest';
+
+type StringKeysAndUndefined = ConditionalKeys<Example, string | undefined>;
+//=> 'a' | 'c'
+```
+
+@category Object
+*/
+type ConditionalKeys$5<Base, Condition> =
+{
+	// Map through all the keys of the given base type.
+	[Key in keyof Base]-?:
+	// Pick only keys with types extending the given `Condition` type.
+	Base[Key] extends Condition
+	// Retain this key
+	// If the value for the key extends never, only include it if `Condition` also extends never
+		? IfNever$5<Base[Key], IfNever$5<Condition, Key, never>, Key>
+	// Discard this key since the condition fails.
+		: never;
+	// Convert the produced object into a union type of the keys which passed the conditional test.
+}[keyof Base];
+
+/**
+Exclude keys from a shape that matches the given `Condition`.
+
+This is useful when you want to create a new type with a specific set of keys from a shape. For example, you might want to exclude all the primitive properties from a class and form a new shape containing everything but the primitive properties.
+
+@example
+```
+import type {Primitive, ConditionalExcept} from 'type-fest';
+
+class Awesome {
+	name: string;
+	successes: number;
+	failures: bigint;
+
+	run() {}
+}
+
+type ExceptPrimitivesFromAwesome = ConditionalExcept<Awesome, Primitive>;
+//=> {run: () => void}
+```
+
+@example
+```
+import type {ConditionalExcept} from 'type-fest';
+
+interface Example {
+	a: string;
+	b: string | number;
+	c: () => void;
+	d: {};
+}
+
+type NonStringKeysOnly = ConditionalExcept<Example, string>;
+//=> {b: string | number; c: () => void; d: {}}
+```
+
+@category Object
+*/
+type ConditionalExcept$5<Base, Condition> = Except$5<
+Base,
+ConditionalKeys$5<Base, Condition>
+>;
+
+/**
+ * Descriptors are objects that describe the API of a module, and the module
+ * can either be a REST module or a host module.
+ * This type is recursive, so it can describe nested modules.
+ */
+type Descriptors$5 = RESTFunctionDescriptor$5 | AmbassadorFunctionDescriptor$5 | HostModule$5<any, any> | EventDefinition$5<any> | ServicePluginDefinition$5<any> | {
+    [key: string]: Descriptors$5 | PublicMetadata$5 | any;
+};
+/**
+ * This type takes in a descriptors object of a certain Host (including an `unknown` host)
+ * and returns an object with the same structure, but with all descriptors replaced with their API.
+ * Any non-descriptor properties are removed from the returned object, including descriptors that
+ * do not match the given host (as they will not work with the given host).
+ */
+type BuildDescriptors$5<T extends Descriptors$5, H extends Host$5<any> | undefined, Depth extends number = 5> = {
+    done: T;
+    recurse: T extends {
+        __type: typeof SERVICE_PLUGIN_ERROR_TYPE$5;
+    } ? never : T extends AmbassadorFunctionDescriptor$5 ? BuildAmbassadorFunction$5<T> : T extends RESTFunctionDescriptor$5 ? BuildRESTFunction$5<T> : T extends EventDefinition$5<any> ? BuildEventDefinition$5<T> : T extends ServicePluginDefinition$5<any> ? BuildServicePluginDefinition$5<T> : T extends HostModule$5<any, any> ? HostModuleAPI$5<T> : ConditionalExcept$5<{
+        [Key in keyof T]: T[Key] extends Descriptors$5 ? BuildDescriptors$5<T[Key], H, [
+            -1,
+            0,
+            1,
+            2,
+            3,
+            4,
+            5
+        ][Depth]> : never;
+    }, EmptyObject$5>;
+}[Depth extends -1 ? 'done' : 'recurse'];
+type PublicMetadata$5 = {
+    PACKAGE_NAME?: string;
+};
+
+declare global {
+    interface ContextualClient {
+    }
+}
+/**
+ * A type used to create concerete types from SDK descriptors in
+ * case a contextual client is available.
+ */
+type MaybeContext$5<T extends Descriptors$5> = globalThis.ContextualClient extends {
+    host: Host$5;
+} ? BuildDescriptors$5<T, globalThis.ContextualClient['host']> : T;
+
 interface ContactAttachment extends ContactAttachmentMediaOneOf {
     /** The attachment's image (if the attachment is of type IMAGE) */
     image?: string;
@@ -420,7 +854,7 @@ interface GetAttachmentIdentifiers {
     attachmentId: string;
 }
 
-declare function generateAttachmentUploadUrl$1(httpClient: HttpClient): GenerateAttachmentUploadUrlSignature;
+declare function generateAttachmentUploadUrl$1(httpClient: HttpClient$5): GenerateAttachmentUploadUrlSignature;
 interface GenerateAttachmentUploadUrlSignature {
     /**
      * Generates an upload URL to allow external clients to upload a file as an attachment to a given contact.
@@ -432,7 +866,7 @@ interface GenerateAttachmentUploadUrlSignature {
      */
     (contactId: string, fileName: string, options: GenerateAttachmentUploadUrlOptions): Promise<GenerateAttachmentUploadUrlResponse & GenerateAttachmentUploadUrlResponseNonNullableFields>;
 }
-declare function listAttachments$1(httpClient: HttpClient): ListAttachmentsSignature;
+declare function listAttachments$1(httpClient: HttpClient$5): ListAttachmentsSignature;
 interface ListAttachmentsSignature {
     /**
      * List Attachments.
@@ -440,14 +874,14 @@ interface ListAttachmentsSignature {
      */
     (contactId: string, options?: ListAttachmentsOptions | undefined): Promise<ListAttachmentsResponse & ListAttachmentsResponseNonNullableFields>;
 }
-declare function deleteAttachment$1(httpClient: HttpClient): DeleteAttachmentSignature;
+declare function deleteAttachment$1(httpClient: HttpClient$5): DeleteAttachmentSignature;
 interface DeleteAttachmentSignature {
     /**
      * Deletes an attachment from contact
      */
     (identifiers: DeleteAttachmentIdentifiers): Promise<void>;
 }
-declare function getAttachment$1(httpClient: HttpClient): GetAttachmentSignature;
+declare function getAttachment$1(httpClient: HttpClient$5): GetAttachmentSignature;
 interface GetAttachmentSignature {
     /**
      * Retrieves an attachment.
@@ -455,15 +889,15 @@ interface GetAttachmentSignature {
      */
     (identifiers: GetAttachmentIdentifiers): Promise<ContactAttachment & ContactAttachmentNonNullableFields>;
 }
-declare const onAttachmentCreated$1: EventDefinition<AttachmentCreatedEnvelope, "wix.contacts.v4.attachment_created">;
-declare const onAttachmentDeleted$1: EventDefinition<AttachmentDeletedEnvelope, "wix.contacts.v4.attachment_deleted">;
+declare const onAttachmentCreated$1: EventDefinition$5<AttachmentCreatedEnvelope, "wix.contacts.v4.attachment_created">;
+declare const onAttachmentDeleted$1: EventDefinition$5<AttachmentDeletedEnvelope, "wix.contacts.v4.attachment_deleted">;
 
-declare function createEventModule$4<T extends EventDefinition<any, string>>(eventDefinition: T): BuildEventDefinition<T> & T;
+declare function createEventModule$4<T extends EventDefinition$5<any, string>>(eventDefinition: T): BuildEventDefinition$5<T> & T;
 
-declare const generateAttachmentUploadUrl: BuildRESTFunction<typeof generateAttachmentUploadUrl$1> & typeof generateAttachmentUploadUrl$1;
-declare const listAttachments: BuildRESTFunction<typeof listAttachments$1> & typeof listAttachments$1;
-declare const deleteAttachment: BuildRESTFunction<typeof deleteAttachment$1> & typeof deleteAttachment$1;
-declare const getAttachment: BuildRESTFunction<typeof getAttachment$1> & typeof getAttachment$1;
+declare const generateAttachmentUploadUrl: MaybeContext$5<BuildRESTFunction$5<typeof generateAttachmentUploadUrl$1> & typeof generateAttachmentUploadUrl$1>;
+declare const listAttachments: MaybeContext$5<BuildRESTFunction$5<typeof listAttachments$1> & typeof listAttachments$1>;
+declare const deleteAttachment: MaybeContext$5<BuildRESTFunction$5<typeof deleteAttachment$1> & typeof deleteAttachment$1>;
+declare const getAttachment: MaybeContext$5<BuildRESTFunction$5<typeof getAttachment$1> & typeof getAttachment$1>;
 
 type _publicOnAttachmentCreatedType = typeof onAttachmentCreated$1;
 /**
@@ -524,6 +958,484 @@ declare namespace context$5 {
   export { type ActionEvent$4 as ActionEvent, type context$5_AttachmentCreatedEnvelope as AttachmentCreatedEnvelope, type context$5_AttachmentDeletedEnvelope as AttachmentDeletedEnvelope, type context$5_AttachmentMedia as AttachmentMedia, type context$5_AttachmentMediaMediaOneOf as AttachmentMediaMediaOneOf, type context$5_AttachmentMetadata as AttachmentMetadata, type context$5_AttachmentSource as AttachmentSource, context$5_AttachmentType as AttachmentType, type BaseEventMetadata$4 as BaseEventMetadata, type context$5_ContactAttachment as ContactAttachment, type context$5_ContactAttachmentMediaOneOf as ContactAttachmentMediaOneOf, type context$5_ContactAttachmentNonNullableFields as ContactAttachmentNonNullableFields, type context$5_CreateDemoAttachmentRequest as CreateDemoAttachmentRequest, type context$5_CreateDemoAttachmentResponse as CreateDemoAttachmentResponse, type context$5_CrmAttachment as CrmAttachment, context$5_CrmAttachmentAttachmentType as CrmAttachmentAttachmentType, type context$5_CrmAttachmentUploadedEvent as CrmAttachmentUploadedEvent, type context$5_DeleteAttachmentIdentifiers as DeleteAttachmentIdentifiers, type context$5_DeleteAttachmentRequest as DeleteAttachmentRequest, type context$5_DeleteAttachmentResponse as DeleteAttachmentResponse, context$5_DemoContactType as DemoContactType, type DomainEvent$4 as DomainEvent, type DomainEventBodyOneOf$4 as DomainEventBodyOneOf, type Empty$1 as Empty, type EntityCreatedEvent$4 as EntityCreatedEvent, type EntityDeletedEvent$4 as EntityDeletedEvent, type EntityUpdatedEvent$4 as EntityUpdatedEvent, type EventMetadata$4 as EventMetadata, type context$5_GenerateAttachmentUploadUrlOptions as GenerateAttachmentUploadUrlOptions, type context$5_GenerateAttachmentUploadUrlRequest as GenerateAttachmentUploadUrlRequest, type context$5_GenerateAttachmentUploadUrlResponse as GenerateAttachmentUploadUrlResponse, type context$5_GenerateAttachmentUploadUrlResponseNonNullableFields as GenerateAttachmentUploadUrlResponseNonNullableFields, type context$5_GetAttachmentIdentifiers as GetAttachmentIdentifiers, type context$5_GetAttachmentRequest as GetAttachmentRequest, type context$5_GetAttachmentResponse as GetAttachmentResponse, type context$5_GetAttachmentResponseNonNullableFields as GetAttachmentResponseNonNullableFields, type IdentificationData$5 as IdentificationData, type IdentificationDataIdOneOf$5 as IdentificationDataIdOneOf, type context$5_ListAttachmentsOptions as ListAttachmentsOptions, type context$5_ListAttachmentsRequest as ListAttachmentsRequest, type context$5_ListAttachmentsResponse as ListAttachmentsResponse, type context$5_ListAttachmentsResponseNonNullableFields as ListAttachmentsResponseNonNullableFields, type context$5_MediaFileUploadedEvent as MediaFileUploadedEvent, type MessageEnvelope$5 as MessageEnvelope, type Paging$4 as Paging, type PagingMetadata$3 as PagingMetadata, WebhookIdentityType$5 as WebhookIdentityType, type context$5__publicOnAttachmentCreatedType as _publicOnAttachmentCreatedType, type context$5__publicOnAttachmentDeletedType as _publicOnAttachmentDeletedType, context$5_deleteAttachment as deleteAttachment, context$5_generateAttachmentUploadUrl as generateAttachmentUploadUrl, context$5_getAttachment as getAttachment, context$5_listAttachments as listAttachments, context$5_onAttachmentCreated as onAttachmentCreated, context$5_onAttachmentDeleted as onAttachmentDeleted, onAttachmentCreated$1 as publicOnAttachmentCreated, onAttachmentDeleted$1 as publicOnAttachmentDeleted };
 }
 
+type HostModule$4<T, H extends Host$4> = {
+    __type: 'host';
+    create(host: H): T;
+};
+type HostModuleAPI$4<T extends HostModule$4<any, any>> = T extends HostModule$4<infer U, any> ? U : never;
+type Host$4<Environment = unknown> = {
+    channel: {
+        observeState(callback: (props: unknown, environment: Environment) => unknown): {
+            disconnect: () => void;
+        } | Promise<{
+            disconnect: () => void;
+        }>;
+    };
+    environment?: Environment;
+    /**
+     * Optional name of the environment, use for logging
+     */
+    name?: string;
+    /**
+     * Optional bast url to use for API requests, for example `www.wixapis.com`
+     */
+    apiBaseUrl?: string;
+    /**
+     * Possible data to be provided by every host, for cross cutting concerns
+     * like internationalization, billing, etc.
+     */
+    essentials?: {
+        /**
+         * The language of the currently viewed session
+         */
+        language?: string;
+        /**
+         * The locale of the currently viewed session
+         */
+        locale?: string;
+        /**
+         * Any headers that should be passed through to the API requests
+         */
+        passThroughHeaders?: Record<string, string>;
+    };
+};
+
+type RESTFunctionDescriptor$4<T extends (...args: any[]) => any = (...args: any[]) => any> = (httpClient: HttpClient$4) => T;
+interface HttpClient$4 {
+    request<TResponse, TData = any>(req: RequestOptionsFactory$4<TResponse, TData>): Promise<HttpResponse$4<TResponse>>;
+    fetchWithAuth: typeof fetch;
+    wixAPIFetch: (relativeUrl: string, options: RequestInit) => Promise<Response>;
+    getActiveToken?: () => string | undefined;
+}
+type RequestOptionsFactory$4<TResponse = any, TData = any> = (context: any) => RequestOptions$4<TResponse, TData>;
+type HttpResponse$4<T = any> = {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: any;
+    request?: any;
+};
+type RequestOptions$4<_TResponse = any, Data = any> = {
+    method: 'POST' | 'GET' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+    url: string;
+    data?: Data;
+    params?: URLSearchParams;
+} & APIMetadata$4;
+type APIMetadata$4 = {
+    methodFqn?: string;
+    entityFqdn?: string;
+    packageName?: string;
+};
+type BuildRESTFunction$4<T extends RESTFunctionDescriptor$4> = T extends RESTFunctionDescriptor$4<infer U> ? U : never;
+type EventDefinition$4<Payload = unknown, Type extends string = string> = {
+    __type: 'event-definition';
+    type: Type;
+    isDomainEvent?: boolean;
+    transformations?: (envelope: unknown) => Payload;
+    __payload: Payload;
+};
+declare function EventDefinition$4<Type extends string>(type: Type, isDomainEvent?: boolean, transformations?: (envelope: any) => unknown): <Payload = unknown>() => EventDefinition$4<Payload, Type>;
+type EventHandler$4<T extends EventDefinition$4> = (payload: T['__payload']) => void | Promise<void>;
+type BuildEventDefinition$4<T extends EventDefinition$4<any, string>> = (handler: EventHandler$4<T>) => void;
+
+type ServicePluginMethodInput$4 = {
+    request: any;
+    metadata: any;
+};
+type ServicePluginContract$4 = Record<string, (payload: ServicePluginMethodInput$4) => unknown | Promise<unknown>>;
+type ServicePluginMethodMetadata$4 = {
+    name: string;
+    primaryHttpMappingPath: string;
+    transformations: {
+        fromREST: (...args: unknown[]) => ServicePluginMethodInput$4;
+        toREST: (...args: unknown[]) => unknown;
+    };
+};
+type ServicePluginDefinition$4<Contract extends ServicePluginContract$4> = {
+    __type: 'service-plugin-definition';
+    componentType: string;
+    methods: ServicePluginMethodMetadata$4[];
+    __contract: Contract;
+};
+declare function ServicePluginDefinition$4<Contract extends ServicePluginContract$4>(componentType: string, methods: ServicePluginMethodMetadata$4[]): ServicePluginDefinition$4<Contract>;
+type BuildServicePluginDefinition$4<T extends ServicePluginDefinition$4<any>> = (implementation: T['__contract']) => void;
+declare const SERVICE_PLUGIN_ERROR_TYPE$4 = "wix_spi_error";
+
+type RequestContext$4 = {
+    isSSR: boolean;
+    host: string;
+    protocol?: string;
+};
+type ResponseTransformer$4 = (data: any, headers?: any) => any;
+/**
+ * Ambassador request options types are copied mostly from AxiosRequestConfig.
+ * They are copied and not imported to reduce the amount of dependencies (to reduce install time).
+ * https://github.com/axios/axios/blob/3f53eb6960f05a1f88409c4b731a40de595cb825/index.d.ts#L307-L315
+ */
+type Method$4 = 'get' | 'GET' | 'delete' | 'DELETE' | 'head' | 'HEAD' | 'options' | 'OPTIONS' | 'post' | 'POST' | 'put' | 'PUT' | 'patch' | 'PATCH' | 'purge' | 'PURGE' | 'link' | 'LINK' | 'unlink' | 'UNLINK';
+type AmbassadorRequestOptions$4<T = any> = {
+    _?: T;
+    url?: string;
+    method?: Method$4;
+    params?: any;
+    data?: any;
+    transformResponse?: ResponseTransformer$4 | ResponseTransformer$4[];
+};
+type AmbassadorFactory$4<Request, Response> = (payload: Request) => ((context: RequestContext$4) => AmbassadorRequestOptions$4<Response>) & {
+    __isAmbassador: boolean;
+};
+type AmbassadorFunctionDescriptor$4<Request = any, Response = any> = AmbassadorFactory$4<Request, Response>;
+type BuildAmbassadorFunction$4<T extends AmbassadorFunctionDescriptor$4> = T extends AmbassadorFunctionDescriptor$4<infer Request, infer Response> ? (req: Request) => Promise<Response> : never;
+
+declare global {
+	// eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
+	interface SymbolConstructor {
+		readonly observable: symbol;
+	}
+}
+
+declare const emptyObjectSymbol$4: unique symbol;
+
+/**
+Represents a strictly empty plain object, the `{}` value.
+
+When you annotate something as the type `{}`, it can be anything except `null` and `undefined`. This means that you cannot use `{}` to represent an empty plain object ([read more](https://stackoverflow.com/questions/47339869/typescript-empty-object-and-any-difference/52193484#52193484)).
+
+@example
+```
+import type {EmptyObject} from 'type-fest';
+
+// The following illustrates the problem with `{}`.
+const foo1: {} = {}; // Pass
+const foo2: {} = []; // Pass
+const foo3: {} = 42; // Pass
+const foo4: {} = {a: 1}; // Pass
+
+// With `EmptyObject` only the first case is valid.
+const bar1: EmptyObject = {}; // Pass
+const bar2: EmptyObject = 42; // Fail
+const bar3: EmptyObject = []; // Fail
+const bar4: EmptyObject = {a: 1}; // Fail
+```
+
+Unfortunately, `Record<string, never>`, `Record<keyof any, never>` and `Record<never, never>` do not work. See {@link https://github.com/sindresorhus/type-fest/issues/395 #395}.
+
+@category Object
+*/
+type EmptyObject$4 = {[emptyObjectSymbol$4]?: never};
+
+/**
+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$4<A, B> =
+	(<G>() => G extends A ? 1 : 2) extends
+	(<G>() => G extends B ? 1 : 2)
+		? true
+		: false;
+
+/**
+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$4<KeyType, ExcludeType> = IsEqual$4<KeyType, ExcludeType> extends true ? never : (KeyType extends ExcludeType ? never : KeyType);
+
+type ExceptOptions$4 = {
+	/**
+	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;
+};
+
+/**
+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}
+
+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>>
+
+const fooWithoutB: FooWithoutB = {a: 1, b: '2'};
+//=> errors at 'b': Type 'string' is not assignable to type 'undefined'.
+```
+
+@category Object
+*/
+type Except$4<ObjectType, KeysType extends keyof ObjectType, Options extends ExceptOptions$4 = {requireExactProps: false}> = {
+	[KeyType in keyof ObjectType as Filter$4<KeyType, KeysType>]: ObjectType[KeyType];
+} & (Options['requireExactProps'] extends true
+	? Partial<Record<KeysType, never>>
+	: {});
+
+/**
+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';
+
+// https://github.com/andnp/SimplyTyped/blob/master/src/types/strings.ts
+type AreStringsEqual<A extends string, B extends string> =
+	And<
+		IsNever<Exclude<A, B>> extends true ? true : false,
+		IsNever<Exclude<B, A>> extends true ? true : false
+	>;
+
+type EndIfEqual<I extends string, O extends string> =
+	AreStringsEqual<I, O> extends true
+		? never
+		: void;
+
+function endIfEqual<I extends string, O extends string>(input: I, output: O): EndIfEqual<I, O> {
+	if (input === output) {
+		process.exit(0);
+	}
+}
+
+endIfEqual('abc', 'abc');
+//=> never
+
+endIfEqual('abc', '123');
+//=> void
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsNever$4<T> = [T] extends [never] ? true : false;
+
+/**
+An if-else-like type that resolves depending on whether the given type is `never`.
+
+@see {@link IsNever}
+
+@example
+```
+import type {IfNever} from 'type-fest';
+
+type ShouldBeTrue = IfNever<never>;
+//=> true
+
+type ShouldBeBar = IfNever<'not never', 'foo', 'bar'>;
+//=> 'bar'
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IfNever$4<T, TypeIfNever = true, TypeIfNotNever = false> = (
+	IsNever$4<T> extends true ? TypeIfNever : TypeIfNotNever
+);
+
+/**
+Extract the keys from a type where the value type of the key extends the given `Condition`.
+
+Internally this is used for the `ConditionalPick` and `ConditionalExcept` types.
+
+@example
+```
+import type {ConditionalKeys} from 'type-fest';
+
+interface Example {
+	a: string;
+	b: string | number;
+	c?: string;
+	d: {};
+}
+
+type StringKeysOnly = ConditionalKeys<Example, string>;
+//=> 'a'
+```
+
+To support partial types, make sure your `Condition` is a union of undefined (for example, `string | undefined`) as demonstrated below.
+
+@example
+```
+import type {ConditionalKeys} from 'type-fest';
+
+type StringKeysAndUndefined = ConditionalKeys<Example, string | undefined>;
+//=> 'a' | 'c'
+```
+
+@category Object
+*/
+type ConditionalKeys$4<Base, Condition> =
+{
+	// Map through all the keys of the given base type.
+	[Key in keyof Base]-?:
+	// Pick only keys with types extending the given `Condition` type.
+	Base[Key] extends Condition
+	// Retain this key
+	// If the value for the key extends never, only include it if `Condition` also extends never
+		? IfNever$4<Base[Key], IfNever$4<Condition, Key, never>, Key>
+	// Discard this key since the condition fails.
+		: never;
+	// Convert the produced object into a union type of the keys which passed the conditional test.
+}[keyof Base];
+
+/**
+Exclude keys from a shape that matches the given `Condition`.
+
+This is useful when you want to create a new type with a specific set of keys from a shape. For example, you might want to exclude all the primitive properties from a class and form a new shape containing everything but the primitive properties.
+
+@example
+```
+import type {Primitive, ConditionalExcept} from 'type-fest';
+
+class Awesome {
+	name: string;
+	successes: number;
+	failures: bigint;
+
+	run() {}
+}
+
+type ExceptPrimitivesFromAwesome = ConditionalExcept<Awesome, Primitive>;
+//=> {run: () => void}
+```
+
+@example
+```
+import type {ConditionalExcept} from 'type-fest';
+
+interface Example {
+	a: string;
+	b: string | number;
+	c: () => void;
+	d: {};
+}
+
+type NonStringKeysOnly = ConditionalExcept<Example, string>;
+//=> {b: string | number; c: () => void; d: {}}
+```
+
+@category Object
+*/
+type ConditionalExcept$4<Base, Condition> = Except$4<
+Base,
+ConditionalKeys$4<Base, Condition>
+>;
+
+/**
+ * Descriptors are objects that describe the API of a module, and the module
+ * can either be a REST module or a host module.
+ * This type is recursive, so it can describe nested modules.
+ */
+type Descriptors$4 = RESTFunctionDescriptor$4 | AmbassadorFunctionDescriptor$4 | HostModule$4<any, any> | EventDefinition$4<any> | ServicePluginDefinition$4<any> | {
+    [key: string]: Descriptors$4 | PublicMetadata$4 | any;
+};
+/**
+ * This type takes in a descriptors object of a certain Host (including an `unknown` host)
+ * and returns an object with the same structure, but with all descriptors replaced with their API.
+ * Any non-descriptor properties are removed from the returned object, including descriptors that
+ * do not match the given host (as they will not work with the given host).
+ */
+type BuildDescriptors$4<T extends Descriptors$4, H extends Host$4<any> | undefined, Depth extends number = 5> = {
+    done: T;
+    recurse: T extends {
+        __type: typeof SERVICE_PLUGIN_ERROR_TYPE$4;
+    } ? never : T extends AmbassadorFunctionDescriptor$4 ? BuildAmbassadorFunction$4<T> : T extends RESTFunctionDescriptor$4 ? BuildRESTFunction$4<T> : T extends EventDefinition$4<any> ? BuildEventDefinition$4<T> : T extends ServicePluginDefinition$4<any> ? BuildServicePluginDefinition$4<T> : T extends HostModule$4<any, any> ? HostModuleAPI$4<T> : ConditionalExcept$4<{
+        [Key in keyof T]: T[Key] extends Descriptors$4 ? BuildDescriptors$4<T[Key], H, [
+            -1,
+            0,
+            1,
+            2,
+            3,
+            4,
+            5
+        ][Depth]> : never;
+    }, EmptyObject$4>;
+}[Depth extends -1 ? 'done' : 'recurse'];
+type PublicMetadata$4 = {
+    PACKAGE_NAME?: string;
+};
+
+declare global {
+    interface ContextualClient {
+    }
+}
+/**
+ * A type used to create concerete types from SDK descriptors in
+ * case a contextual client is available.
+ */
+type MaybeContext$4<T extends Descriptors$4> = globalThis.ContextualClient extends {
+    host: Host$4;
+} ? BuildDescriptors$4<T, globalThis.ContextualClient['host']> : T;
+
 interface Contact {
     /**
      * Contact ID.
@@ -2439,7 +3351,7 @@ interface GetContactOptions {
     fieldsets?: ContactFieldSet[];
 }
 
-declare function createContact$1(httpClient: HttpClient): CreateContactSignature;
+declare function createContact$1(httpClient: HttpClient$4): CreateContactSignature;
 interface CreateContactSignature {
     /**
      * Creates a new contact.
@@ -2460,7 +3372,7 @@ interface CreateContactSignature {
      */
     (info: ContactInfo$2, options?: CreateContactOptions | undefined): Promise<CreateContactResponse & CreateContactResponseNonNullableFields>;
 }
-declare function updateContact$1(httpClient: HttpClient): UpdateContactSignature;
+declare function updateContact$1(httpClient: HttpClient$4): UpdateContactSignature;
 interface UpdateContactSignature {
     /**
      * Updates a contact's properties.
@@ -2480,7 +3392,7 @@ interface UpdateContactSignature {
      */
     (contactId: string, info: ContactInfo$2, revision: number | null, options?: UpdateContactOptions | undefined): Promise<UpdateContactResponse & UpdateContactResponseNonNullableFields>;
 }
-declare function mergeContacts$1(httpClient: HttpClient): MergeContactsSignature;
+declare function mergeContacts$1(httpClient: HttpClient$4): MergeContactsSignature;
 interface MergeContactsSignature {
     /**
      * Merges source contacts into a target contact.
@@ -2506,7 +3418,7 @@ interface MergeContactsSignature {
      */
     (targetContactId: string, targetContactRevision: number | null, options?: MergeContactsOptions | undefined): Promise<MergeContactsResponse & MergeContactsResponseNonNullableFields>;
 }
-declare function deleteContact$1(httpClient: HttpClient): DeleteContactSignature;
+declare function deleteContact$1(httpClient: HttpClient$4): DeleteContactSignature;
 interface DeleteContactSignature {
     /**
      * Deletes a contact who is not a site member or contributor.
@@ -2524,7 +3436,7 @@ interface DeleteContactSignature {
      */
     (contactId: string): Promise<void>;
 }
-declare function labelContact$1(httpClient: HttpClient): LabelContactSignature;
+declare function labelContact$1(httpClient: HttpClient$4): LabelContactSignature;
 interface LabelContactSignature {
     /**
      * Adds labels to a contact.
@@ -2546,7 +3458,7 @@ interface LabelContactSignature {
      */
     (contactId: string, labelKeys: string[]): Promise<LabelContactResponse & LabelContactResponseNonNullableFields>;
 }
-declare function unlabelContact$1(httpClient: HttpClient): UnlabelContactSignature;
+declare function unlabelContact$1(httpClient: HttpClient$4): UnlabelContactSignature;
 interface UnlabelContactSignature {
     /**
      * Removes labels from a contact.
@@ -2562,7 +3474,7 @@ interface UnlabelContactSignature {
      */
     (contactId: string, labelKeys: string[]): Promise<UnlabelContactResponse & UnlabelContactResponseNonNullableFields>;
 }
-declare function queryContacts$1(httpClient: HttpClient): QueryContactsSignature;
+declare function queryContacts$1(httpClient: HttpClient$4): QueryContactsSignature;
 interface QueryContactsSignature {
     /**
      * Creates a query to retrieve a list of contacts.
@@ -2584,7 +3496,7 @@ interface QueryContactsSignature {
      */
     (options?: QueryContactsOptions | undefined): ContactsQueryBuilder;
 }
-declare function getContact$1(httpClient: HttpClient): GetContactSignature;
+declare function getContact$1(httpClient: HttpClient$4): GetContactSignature;
 interface GetContactSignature {
     /**
      * Retrieves a contact.
@@ -2605,21 +3517,21 @@ interface GetContactSignature {
      */
     (_id: string, options?: GetContactOptions | undefined): Promise<Contact & ContactNonNullableFields>;
 }
-declare const onContactCreated$1: EventDefinition<ContactCreatedEnvelope, "wix.contacts.v4.contact_created">;
-declare const onContactUpdated$1: EventDefinition<ContactUpdatedEnvelope, "wix.contacts.v4.contact_updated">;
-declare const onContactMerged$1: EventDefinition<ContactMergedEnvelope, "wix.contacts.v4.contact_merged">;
-declare const onContactDeleted$1: EventDefinition<ContactDeletedEnvelope, "wix.contacts.v4.contact_deleted">;
+declare const onContactCreated$1: EventDefinition$4<ContactCreatedEnvelope, "wix.contacts.v4.contact_created">;
+declare const onContactUpdated$1: EventDefinition$4<ContactUpdatedEnvelope, "wix.contacts.v4.contact_updated">;
+declare const onContactMerged$1: EventDefinition$4<ContactMergedEnvelope, "wix.contacts.v4.contact_merged">;
+declare const onContactDeleted$1: EventDefinition$4<ContactDeletedEnvelope, "wix.contacts.v4.contact_deleted">;
 
-declare function createEventModule$3<T extends EventDefinition<any, string>>(eventDefinition: T): BuildEventDefinition<T> & T;
+declare function createEventModule$3<T extends EventDefinition$4<any, string>>(eventDefinition: T): BuildEventDefinition$4<T> & T;
 
-declare const createContact: BuildRESTFunction<typeof createContact$1> & typeof createContact$1;
-declare const updateContact: BuildRESTFunction<typeof updateContact$1> & typeof updateContact$1;
-declare const mergeContacts: BuildRESTFunction<typeof mergeContacts$1> & typeof mergeContacts$1;
-declare const deleteContact: BuildRESTFunction<typeof deleteContact$1> & typeof deleteContact$1;
-declare const labelContact: BuildRESTFunction<typeof labelContact$1> & typeof labelContact$1;
-declare const unlabelContact: BuildRESTFunction<typeof unlabelContact$1> & typeof unlabelContact$1;
-declare const queryContacts: BuildRESTFunction<typeof queryContacts$1> & typeof queryContacts$1;
-declare const getContact: BuildRESTFunction<typeof getContact$1> & typeof getContact$1;
+declare const createContact: MaybeContext$4<BuildRESTFunction$4<typeof createContact$1> & typeof createContact$1>;
+declare const updateContact: MaybeContext$4<BuildRESTFunction$4<typeof updateContact$1> & typeof updateContact$1>;
+declare const mergeContacts: MaybeContext$4<BuildRESTFunction$4<typeof mergeContacts$1> & typeof mergeContacts$1>;
+declare const deleteContact: MaybeContext$4<BuildRESTFunction$4<typeof deleteContact$1> & typeof deleteContact$1>;
+declare const labelContact: MaybeContext$4<BuildRESTFunction$4<typeof labelContact$1> & typeof labelContact$1>;
+declare const unlabelContact: MaybeContext$4<BuildRESTFunction$4<typeof unlabelContact$1> & typeof unlabelContact$1>;
+declare const queryContacts: MaybeContext$4<BuildRESTFunction$4<typeof queryContacts$1> & typeof queryContacts$1>;
+declare const getContact: MaybeContext$4<BuildRESTFunction$4<typeof getContact$1> & typeof getContact$1>;
 
 type _publicOnContactCreatedType = typeof onContactCreated$1;
 /**
@@ -2806,6 +3718,484 @@ declare namespace context$4 {
   export { context$4_Action as Action, type ActionEvent$3 as ActionEvent, type ActivityIcon$1 as ActivityIcon, type Address$1 as Address, type AddressLocation$1 as AddressLocation, type AddressStreetOneOf$1 as AddressStreetOneOf, AddressTag$1 as AddressTag, type context$4_ApplicationError as ApplicationError, type AssigneesWrapper$1 as AssigneesWrapper, type BaseEventMetadata$3 as BaseEventMetadata, type context$4_BulkActionMetadata as BulkActionMetadata, type context$4_BulkAddSegmentToContactsRequest as BulkAddSegmentToContactsRequest, type context$4_BulkAddSegmentToContactsResponse as BulkAddSegmentToContactsResponse, type context$4_BulkDeleteContactsRequest as BulkDeleteContactsRequest, type context$4_BulkDeleteContactsResponse as BulkDeleteContactsResponse, type context$4_BulkLabelAndUnlabelContactsRequest as BulkLabelAndUnlabelContactsRequest, type context$4_BulkLabelAndUnlabelContactsResponse as BulkLabelAndUnlabelContactsResponse, type context$4_BulkRemoveSegmentFromContactsRequest as BulkRemoveSegmentFromContactsRequest, type context$4_BulkRemoveSegmentFromContactsResponse as BulkRemoveSegmentFromContactsResponse, type context$4_BulkUpdateContactsRequest as BulkUpdateContactsRequest, type context$4_BulkUpdateContactsResponse as BulkUpdateContactsResponse, type context$4_BulkUpsertContactsRequest as BulkUpsertContactsRequest, type context$4_BulkUpsertContactsResponse as BulkUpsertContactsResponse, type context$4_BulkUpsertContactsResponseMetadata as BulkUpsertContactsResponseMetadata, type context$4_Contact as Contact, type ContactActivity$1 as ContactActivity, ContactActivityType$1 as ContactActivityType, type context$4_ContactAddedToSegment as ContactAddedToSegment, type ContactAddress$1 as ContactAddress, type ContactAddressesWrapper$1 as ContactAddressesWrapper, type context$4_ContactChanged as ContactChanged, type context$4_ContactCreatedEnvelope as ContactCreatedEnvelope, type context$4_ContactDeletedEnvelope as ContactDeletedEnvelope, type ContactEmail$1 as ContactEmail, type context$4_ContactEmailSubscriptionUpdated as ContactEmailSubscriptionUpdated, type ContactEmailsWrapper$1 as ContactEmailsWrapper, context$4_ContactFieldSet as ContactFieldSet, type ContactInfo$2 as ContactInfo, type context$4_ContactMerged as ContactMerged, type context$4_ContactMergedEnvelope as ContactMergedEnvelope, type ContactName$1 as ContactName, type context$4_ContactNonNullableFields as ContactNonNullableFields, type ContactPhone$1 as ContactPhone, type context$4_ContactPhoneSubscriptionUpdated as ContactPhoneSubscriptionUpdated, type ContactPhonesWrapper$1 as ContactPhonesWrapper, type ContactPicture$1 as ContactPicture, type context$4_ContactPrimaryInfoUpdated as ContactPrimaryInfoUpdated, type context$4_ContactRemovedFromSegment as ContactRemovedFromSegment, type context$4_ContactSource as ContactSource, ContactSourceType$1 as ContactSourceType, type context$4_ContactSubmitted as ContactSubmitted, type context$4_ContactUpdatedEnvelope as ContactUpdatedEnvelope, type context$4_ContactsFacet as ContactsFacet, context$4_ContactsFacetType as ContactsFacetType, type context$4_ContactsQueryBuilder as ContactsQueryBuilder, type context$4_ContactsQueryResult as ContactsQueryResult, type context$4_CountContactsRequest as CountContactsRequest, type context$4_CountContactsResponse as CountContactsResponse, type context$4_CreateContactOptions as CreateContactOptions, type context$4_CreateContactRequest as CreateContactRequest, type context$4_CreateContactResponse as CreateContactResponse, type context$4_CreateContactResponseNonNullableFields as CreateContactResponseNonNullableFields, type CursorPaging$1 as CursorPaging, type CursorPagingMetadata$1 as CursorPagingMetadata, type Cursors$1 as Cursors, type context$4_DeleteContactRequest as DeleteContactRequest, type context$4_DeleteContactResponse as DeleteContactResponse, type DomainEvent$3 as DomainEvent, type DomainEventBodyOneOf$3 as DomainEventBodyOneOf, type context$4_DuplicateContactExists as DuplicateContactExists, context$4_EmailDeliverabilityStatus as EmailDeliverabilityStatus, EmailTag$1 as EmailTag, type EntityCreatedEvent$3 as EntityCreatedEvent, type EntityDeletedEvent$3 as EntityDeletedEvent, type EntityUpdatedEvent$3 as EntityUpdatedEvent, type context$4_Error as Error, type EventMetadata$3 as EventMetadata, type ExtendedFieldsWrapper$1 as ExtendedFieldsWrapper, type context$4_GeneratePictureUploadUrlRequest as GeneratePictureUploadUrlRequest, type context$4_GeneratePictureUploadUrlResponse as GeneratePictureUploadUrlResponse, type context$4_GetContactOptions as GetContactOptions, type context$4_GetContactRequest as GetContactRequest, type context$4_GetContactResponse as GetContactResponse, type context$4_GetContactResponseNonNullableFields as GetContactResponseNonNullableFields, context$4_GetContactResponseType as GetContactResponseType, type context$4_GroupInfo as GroupInfo, type IdentificationData$4 as IdentificationData, type IdentificationDataIdOneOf$4 as IdentificationDataIdOneOf, ImageProvider$1 as ImageProvider, type context$4_Item as Item, type context$4_ItemMetadata as ItemMetadata, type context$4_LabelAndUnlabelContactRequest as LabelAndUnlabelContactRequest, type context$4_LabelAndUnlabelContactResponse as LabelAndUnlabelContactResponse, type context$4_LabelContactRequest as LabelContactRequest, type context$4_LabelContactResponse as LabelContactResponse, type context$4_LabelContactResponseNonNullableFields as LabelContactResponseNonNullableFields, type LabelsWrapper$1 as LabelsWrapper, type context$4_LastActivityUpdate as LastActivityUpdate, type context$4_ListContactIdsBySegmentRequest as ListContactIdsBySegmentRequest, type context$4_ListContactIdsBySegmentResponse as ListContactIdsBySegmentResponse, type context$4_ListContactsRequest as ListContactsRequest, type context$4_ListContactsResponse as ListContactsResponse, type context$4_ListFacetsRequest as ListFacetsRequest, type context$4_ListFacetsResponse as ListFacetsResponse, type LocationsWrapper$1 as LocationsWrapper, type context$4_MemberInfo as MemberInfo, context$4_MemberStatus as MemberStatus, type context$4_MergeContactsOptions as MergeContactsOptions, type context$4_MergeContactsRequest as MergeContactsRequest, type context$4_MergeContactsResponse as MergeContactsResponse, type context$4_MergeContactsResponseNonNullableFields as MergeContactsResponseNonNullableFields, type MessageEnvelope$4 as MessageEnvelope, type context$4_Metadata as Metadata, context$4_Mode as Mode, type Paging$3 as Paging, type PagingMetadata$2 as PagingMetadata, context$4_PhoneDeliverabilityStatus as PhoneDeliverabilityStatus, PhoneTag$1 as PhoneTag, type context$4_PreviewMergeContactsRequest as PreviewMergeContactsRequest, type context$4_PreviewMergeContactsResponse as PreviewMergeContactsResponse, type context$4_PrimaryContactInfo as PrimaryContactInfo, type context$4_PrimaryEmail as PrimaryEmail, type context$4_PrimaryPhone as PrimaryPhone, type context$4_PrimarySubscriptionStatus as PrimarySubscriptionStatus, context$4_PrivacyStatus as PrivacyStatus, type context$4_ProfileInfo as ProfileInfo, type Query$2 as Query, type context$4_QueryContactsOptions as QueryContactsOptions, type context$4_QueryContactsRequest as QueryContactsRequest, type context$4_QueryContactsResponse as QueryContactsResponse, type context$4_QueryContactsResponseNonNullableFields as QueryContactsResponseNonNullableFields, type context$4_QueryFacetsRequest as QueryFacetsRequest, type context$4_QueryFacetsResponse as QueryFacetsResponse, type RestoreInfo$2 as RestoreInfo, context$4_Role as Role, type context$4_Search as Search, type context$4_SearchContactsRequest as SearchContactsRequest, type context$4_SearchContactsResponse as SearchContactsResponse, type context$4_SearchDetails as SearchDetails, type context$4_SearchPagingMethodOneOf as SearchPagingMethodOneOf, type context$4_SegmentsWrapper as SegmentsWrapper, type context$4_SessionInfo as SessionInfo, SortOrder$3 as SortOrder, type Sorting$3 as Sorting, type StreetAddress$1 as StreetAddress, type Subdivision$1 as Subdivision, SubdivisionType$1 as SubdivisionType, SubmitOperation$1 as SubmitOperation, context$4_SubscriptionStatus as SubscriptionStatus, type context$4_SyncSubmitContactRequest as SyncSubmitContactRequest, type context$4_SyncSubmitContactResponse as SyncSubmitContactResponse, type context$4_UnlabelContactRequest as UnlabelContactRequest, type context$4_UnlabelContactResponse as UnlabelContactResponse, type context$4_UnlabelContactResponseNonNullableFields as UnlabelContactResponseNonNullableFields, type context$4_UpdateContactOptions as UpdateContactOptions, type context$4_UpdateContactRequest as UpdateContactRequest, type context$4_UpdateContactResponse as UpdateContactResponse, type context$4_UpdateContactResponseNonNullableFields as UpdateContactResponseNonNullableFields, type context$4_UpsertContactRequest as UpsertContactRequest, type context$4_UpsertContactResponse as UpsertContactResponse, context$4_UpsertContactResponseAction as UpsertContactResponseAction, type context$4_UserInfo as UserInfo, WebhookIdentityType$4 as WebhookIdentityType, type context$4__publicOnContactCreatedType as _publicOnContactCreatedType, type context$4__publicOnContactDeletedType as _publicOnContactDeletedType, type context$4__publicOnContactMergedType as _publicOnContactMergedType, type context$4__publicOnContactUpdatedType as _publicOnContactUpdatedType, context$4_createContact as createContact, context$4_deleteContact as deleteContact, context$4_getContact as getContact, context$4_labelContact as labelContact, context$4_mergeContacts as mergeContacts, context$4_onContactCreated as onContactCreated, context$4_onContactDeleted as onContactDeleted, context$4_onContactMerged as onContactMerged, context$4_onContactUpdated as onContactUpdated, onContactCreated$1 as publicOnContactCreated, onContactDeleted$1 as publicOnContactDeleted, onContactMerged$1 as publicOnContactMerged, onContactUpdated$1 as publicOnContactUpdated, context$4_queryContacts as queryContacts, context$4_unlabelContact as unlabelContact, context$4_updateContact as updateContact };
 }
 
+type HostModule$3<T, H extends Host$3> = {
+    __type: 'host';
+    create(host: H): T;
+};
+type HostModuleAPI$3<T extends HostModule$3<any, any>> = T extends HostModule$3<infer U, any> ? U : never;
+type Host$3<Environment = unknown> = {
+    channel: {
+        observeState(callback: (props: unknown, environment: Environment) => unknown): {
+            disconnect: () => void;
+        } | Promise<{
+            disconnect: () => void;
+        }>;
+    };
+    environment?: Environment;
+    /**
+     * Optional name of the environment, use for logging
+     */
+    name?: string;
+    /**
+     * Optional bast url to use for API requests, for example `www.wixapis.com`
+     */
+    apiBaseUrl?: string;
+    /**
+     * Possible data to be provided by every host, for cross cutting concerns
+     * like internationalization, billing, etc.
+     */
+    essentials?: {
+        /**
+         * The language of the currently viewed session
+         */
+        language?: string;
+        /**
+         * The locale of the currently viewed session
+         */
+        locale?: string;
+        /**
+         * Any headers that should be passed through to the API requests
+         */
+        passThroughHeaders?: Record<string, string>;
+    };
+};
+
+type RESTFunctionDescriptor$3<T extends (...args: any[]) => any = (...args: any[]) => any> = (httpClient: HttpClient$3) => T;
+interface HttpClient$3 {
+    request<TResponse, TData = any>(req: RequestOptionsFactory$3<TResponse, TData>): Promise<HttpResponse$3<TResponse>>;
+    fetchWithAuth: typeof fetch;
+    wixAPIFetch: (relativeUrl: string, options: RequestInit) => Promise<Response>;
+    getActiveToken?: () => string | undefined;
+}
+type RequestOptionsFactory$3<TResponse = any, TData = any> = (context: any) => RequestOptions$3<TResponse, TData>;
+type HttpResponse$3<T = any> = {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: any;
+    request?: any;
+};
+type RequestOptions$3<_TResponse = any, Data = any> = {
+    method: 'POST' | 'GET' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+    url: string;
+    data?: Data;
+    params?: URLSearchParams;
+} & APIMetadata$3;
+type APIMetadata$3 = {
+    methodFqn?: string;
+    entityFqdn?: string;
+    packageName?: string;
+};
+type BuildRESTFunction$3<T extends RESTFunctionDescriptor$3> = T extends RESTFunctionDescriptor$3<infer U> ? U : never;
+type EventDefinition$3<Payload = unknown, Type extends string = string> = {
+    __type: 'event-definition';
+    type: Type;
+    isDomainEvent?: boolean;
+    transformations?: (envelope: unknown) => Payload;
+    __payload: Payload;
+};
+declare function EventDefinition$3<Type extends string>(type: Type, isDomainEvent?: boolean, transformations?: (envelope: any) => unknown): <Payload = unknown>() => EventDefinition$3<Payload, Type>;
+type EventHandler$3<T extends EventDefinition$3> = (payload: T['__payload']) => void | Promise<void>;
+type BuildEventDefinition$3<T extends EventDefinition$3<any, string>> = (handler: EventHandler$3<T>) => void;
+
+type ServicePluginMethodInput$3 = {
+    request: any;
+    metadata: any;
+};
+type ServicePluginContract$3 = Record<string, (payload: ServicePluginMethodInput$3) => unknown | Promise<unknown>>;
+type ServicePluginMethodMetadata$3 = {
+    name: string;
+    primaryHttpMappingPath: string;
+    transformations: {
+        fromREST: (...args: unknown[]) => ServicePluginMethodInput$3;
+        toREST: (...args: unknown[]) => unknown;
+    };
+};
+type ServicePluginDefinition$3<Contract extends ServicePluginContract$3> = {
+    __type: 'service-plugin-definition';
+    componentType: string;
+    methods: ServicePluginMethodMetadata$3[];
+    __contract: Contract;
+};
+declare function ServicePluginDefinition$3<Contract extends ServicePluginContract$3>(componentType: string, methods: ServicePluginMethodMetadata$3[]): ServicePluginDefinition$3<Contract>;
+type BuildServicePluginDefinition$3<T extends ServicePluginDefinition$3<any>> = (implementation: T['__contract']) => void;
+declare const SERVICE_PLUGIN_ERROR_TYPE$3 = "wix_spi_error";
+
+type RequestContext$3 = {
+    isSSR: boolean;
+    host: string;
+    protocol?: string;
+};
+type ResponseTransformer$3 = (data: any, headers?: any) => any;
+/**
+ * Ambassador request options types are copied mostly from AxiosRequestConfig.
+ * They are copied and not imported to reduce the amount of dependencies (to reduce install time).
+ * https://github.com/axios/axios/blob/3f53eb6960f05a1f88409c4b731a40de595cb825/index.d.ts#L307-L315
+ */
+type Method$3 = 'get' | 'GET' | 'delete' | 'DELETE' | 'head' | 'HEAD' | 'options' | 'OPTIONS' | 'post' | 'POST' | 'put' | 'PUT' | 'patch' | 'PATCH' | 'purge' | 'PURGE' | 'link' | 'LINK' | 'unlink' | 'UNLINK';
+type AmbassadorRequestOptions$3<T = any> = {
+    _?: T;
+    url?: string;
+    method?: Method$3;
+    params?: any;
+    data?: any;
+    transformResponse?: ResponseTransformer$3 | ResponseTransformer$3[];
+};
+type AmbassadorFactory$3<Request, Response> = (payload: Request) => ((context: RequestContext$3) => AmbassadorRequestOptions$3<Response>) & {
+    __isAmbassador: boolean;
+};
+type AmbassadorFunctionDescriptor$3<Request = any, Response = any> = AmbassadorFactory$3<Request, Response>;
+type BuildAmbassadorFunction$3<T extends AmbassadorFunctionDescriptor$3> = T extends AmbassadorFunctionDescriptor$3<infer Request, infer Response> ? (req: Request) => Promise<Response> : never;
+
+declare global {
+	// eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
+	interface SymbolConstructor {
+		readonly observable: symbol;
+	}
+}
+
+declare const emptyObjectSymbol$3: unique symbol;
+
+/**
+Represents a strictly empty plain object, the `{}` value.
+
+When you annotate something as the type `{}`, it can be anything except `null` and `undefined`. This means that you cannot use `{}` to represent an empty plain object ([read more](https://stackoverflow.com/questions/47339869/typescript-empty-object-and-any-difference/52193484#52193484)).
+
+@example
+```
+import type {EmptyObject} from 'type-fest';
+
+// The following illustrates the problem with `{}`.
+const foo1: {} = {}; // Pass
+const foo2: {} = []; // Pass
+const foo3: {} = 42; // Pass
+const foo4: {} = {a: 1}; // Pass
+
+// With `EmptyObject` only the first case is valid.
+const bar1: EmptyObject = {}; // Pass
+const bar2: EmptyObject = 42; // Fail
+const bar3: EmptyObject = []; // Fail
+const bar4: EmptyObject = {a: 1}; // Fail
+```
+
+Unfortunately, `Record<string, never>`, `Record<keyof any, never>` and `Record<never, never>` do not work. See {@link https://github.com/sindresorhus/type-fest/issues/395 #395}.
+
+@category Object
+*/
+type EmptyObject$3 = {[emptyObjectSymbol$3]?: never};
+
+/**
+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$3<A, B> =
+	(<G>() => G extends A ? 1 : 2) extends
+	(<G>() => G extends B ? 1 : 2)
+		? true
+		: false;
+
+/**
+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$3<KeyType, ExcludeType> = IsEqual$3<KeyType, ExcludeType> extends true ? never : (KeyType extends ExcludeType ? never : KeyType);
+
+type ExceptOptions$3 = {
+	/**
+	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;
+};
+
+/**
+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}
+
+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>>
+
+const fooWithoutB: FooWithoutB = {a: 1, b: '2'};
+//=> errors at 'b': Type 'string' is not assignable to type 'undefined'.
+```
+
+@category Object
+*/
+type Except$3<ObjectType, KeysType extends keyof ObjectType, Options extends ExceptOptions$3 = {requireExactProps: false}> = {
+	[KeyType in keyof ObjectType as Filter$3<KeyType, KeysType>]: ObjectType[KeyType];
+} & (Options['requireExactProps'] extends true
+	? Partial<Record<KeysType, never>>
+	: {});
+
+/**
+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';
+
+// https://github.com/andnp/SimplyTyped/blob/master/src/types/strings.ts
+type AreStringsEqual<A extends string, B extends string> =
+	And<
+		IsNever<Exclude<A, B>> extends true ? true : false,
+		IsNever<Exclude<B, A>> extends true ? true : false
+	>;
+
+type EndIfEqual<I extends string, O extends string> =
+	AreStringsEqual<I, O> extends true
+		? never
+		: void;
+
+function endIfEqual<I extends string, O extends string>(input: I, output: O): EndIfEqual<I, O> {
+	if (input === output) {
+		process.exit(0);
+	}
+}
+
+endIfEqual('abc', 'abc');
+//=> never
+
+endIfEqual('abc', '123');
+//=> void
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsNever$3<T> = [T] extends [never] ? true : false;
+
+/**
+An if-else-like type that resolves depending on whether the given type is `never`.
+
+@see {@link IsNever}
+
+@example
+```
+import type {IfNever} from 'type-fest';
+
+type ShouldBeTrue = IfNever<never>;
+//=> true
+
+type ShouldBeBar = IfNever<'not never', 'foo', 'bar'>;
+//=> 'bar'
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IfNever$3<T, TypeIfNever = true, TypeIfNotNever = false> = (
+	IsNever$3<T> extends true ? TypeIfNever : TypeIfNotNever
+);
+
+/**
+Extract the keys from a type where the value type of the key extends the given `Condition`.
+
+Internally this is used for the `ConditionalPick` and `ConditionalExcept` types.
+
+@example
+```
+import type {ConditionalKeys} from 'type-fest';
+
+interface Example {
+	a: string;
+	b: string | number;
+	c?: string;
+	d: {};
+}
+
+type StringKeysOnly = ConditionalKeys<Example, string>;
+//=> 'a'
+```
+
+To support partial types, make sure your `Condition` is a union of undefined (for example, `string | undefined`) as demonstrated below.
+
+@example
+```
+import type {ConditionalKeys} from 'type-fest';
+
+type StringKeysAndUndefined = ConditionalKeys<Example, string | undefined>;
+//=> 'a' | 'c'
+```
+
+@category Object
+*/
+type ConditionalKeys$3<Base, Condition> =
+{
+	// Map through all the keys of the given base type.
+	[Key in keyof Base]-?:
+	// Pick only keys with types extending the given `Condition` type.
+	Base[Key] extends Condition
+	// Retain this key
+	// If the value for the key extends never, only include it if `Condition` also extends never
+		? IfNever$3<Base[Key], IfNever$3<Condition, Key, never>, Key>
+	// Discard this key since the condition fails.
+		: never;
+	// Convert the produced object into a union type of the keys which passed the conditional test.
+}[keyof Base];
+
+/**
+Exclude keys from a shape that matches the given `Condition`.
+
+This is useful when you want to create a new type with a specific set of keys from a shape. For example, you might want to exclude all the primitive properties from a class and form a new shape containing everything but the primitive properties.
+
+@example
+```
+import type {Primitive, ConditionalExcept} from 'type-fest';
+
+class Awesome {
+	name: string;
+	successes: number;
+	failures: bigint;
+
+	run() {}
+}
+
+type ExceptPrimitivesFromAwesome = ConditionalExcept<Awesome, Primitive>;
+//=> {run: () => void}
+```
+
+@example
+```
+import type {ConditionalExcept} from 'type-fest';
+
+interface Example {
+	a: string;
+	b: string | number;
+	c: () => void;
+	d: {};
+}
+
+type NonStringKeysOnly = ConditionalExcept<Example, string>;
+//=> {b: string | number; c: () => void; d: {}}
+```
+
+@category Object
+*/
+type ConditionalExcept$3<Base, Condition> = Except$3<
+Base,
+ConditionalKeys$3<Base, Condition>
+>;
+
+/**
+ * Descriptors are objects that describe the API of a module, and the module
+ * can either be a REST module or a host module.
+ * This type is recursive, so it can describe nested modules.
+ */
+type Descriptors$3 = RESTFunctionDescriptor$3 | AmbassadorFunctionDescriptor$3 | HostModule$3<any, any> | EventDefinition$3<any> | ServicePluginDefinition$3<any> | {
+    [key: string]: Descriptors$3 | PublicMetadata$3 | any;
+};
+/**
+ * This type takes in a descriptors object of a certain Host (including an `unknown` host)
+ * and returns an object with the same structure, but with all descriptors replaced with their API.
+ * Any non-descriptor properties are removed from the returned object, including descriptors that
+ * do not match the given host (as they will not work with the given host).
+ */
+type BuildDescriptors$3<T extends Descriptors$3, H extends Host$3<any> | undefined, Depth extends number = 5> = {
+    done: T;
+    recurse: T extends {
+        __type: typeof SERVICE_PLUGIN_ERROR_TYPE$3;
+    } ? never : T extends AmbassadorFunctionDescriptor$3 ? BuildAmbassadorFunction$3<T> : T extends RESTFunctionDescriptor$3 ? BuildRESTFunction$3<T> : T extends EventDefinition$3<any> ? BuildEventDefinition$3<T> : T extends ServicePluginDefinition$3<any> ? BuildServicePluginDefinition$3<T> : T extends HostModule$3<any, any> ? HostModuleAPI$3<T> : ConditionalExcept$3<{
+        [Key in keyof T]: T[Key] extends Descriptors$3 ? BuildDescriptors$3<T[Key], H, [
+            -1,
+            0,
+            1,
+            2,
+            3,
+            4,
+            5
+        ][Depth]> : never;
+    }, EmptyObject$3>;
+}[Depth extends -1 ? 'done' : 'recurse'];
+type PublicMetadata$3 = {
+    PACKAGE_NAME?: string;
+};
+
+declare global {
+    interface ContextualClient {
+    }
+}
+/**
+ * A type used to create concerete types from SDK descriptors in
+ * case a contextual client is available.
+ */
+type MaybeContext$3<T extends Descriptors$3> = globalThis.ContextualClient extends {
+    host: Host$3;
+} ? BuildDescriptors$3<T, globalThis.ContextualClient['host']> : T;
+
 /** Extended field that was found or created. */
 interface ExtendedField {
     /**
@@ -3377,7 +4767,7 @@ interface FieldsQueryBuilder {
     find: () => Promise<FieldsQueryResult>;
 }
 
-declare function findOrCreateExtendedField$1(httpClient: HttpClient): FindOrCreateExtendedFieldSignature;
+declare function findOrCreateExtendedField$1(httpClient: HttpClient$3): FindOrCreateExtendedFieldSignature;
 interface FindOrCreateExtendedFieldSignature {
     /**
      * Retrieves a custom field with a given name, or creates one if it doesn't exist.
@@ -3406,7 +4796,7 @@ interface FindOrCreateExtendedFieldSignature {
      */
     (displayName: string, dataType: FieldDataType): Promise<FindOrCreateExtendedFieldResponse & FindOrCreateExtendedFieldResponseNonNullableFields>;
 }
-declare function getExtendedField$1(httpClient: HttpClient): GetExtendedFieldSignature;
+declare function getExtendedField$1(httpClient: HttpClient$3): GetExtendedFieldSignature;
 interface GetExtendedFieldSignature {
     /**
      * Retrieves an extended field.
@@ -3425,7 +4815,7 @@ interface GetExtendedFieldSignature {
      */
     (key: string): Promise<ExtendedField & ExtendedFieldNonNullableFields>;
 }
-declare function renameExtendedField$1(httpClient: HttpClient): RenameExtendedFieldSignature;
+declare function renameExtendedField$1(httpClient: HttpClient$3): RenameExtendedFieldSignature;
 interface RenameExtendedFieldSignature {
     /**
      * Renames an extended field.
@@ -3445,7 +4835,7 @@ interface RenameExtendedFieldSignature {
      */
     (key: string, field: RenameExtendedField): Promise<ExtendedField & ExtendedFieldNonNullableFields>;
 }
-declare function deleteExtendedField$1(httpClient: HttpClient): DeleteExtendedFieldSignature;
+declare function deleteExtendedField$1(httpClient: HttpClient$3): DeleteExtendedFieldSignature;
 interface DeleteExtendedFieldSignature {
     /**
      * Deletes an extended field.
@@ -3458,7 +4848,7 @@ interface DeleteExtendedFieldSignature {
      */
     (key: string): Promise<void>;
 }
-declare function queryExtendedFields$1(httpClient: HttpClient): QueryExtendedFieldsSignature;
+declare function queryExtendedFields$1(httpClient: HttpClient$3): QueryExtendedFieldsSignature;
 interface QueryExtendedFieldsSignature {
     /**
      * Creates a query to retrieve a list of extended fields.
@@ -3478,80 +4868,558 @@ interface QueryExtendedFieldsSignature {
      */
     (): FieldsQueryBuilder;
 }
-declare const onExtendedFieldCreated$1: EventDefinition<ExtendedFieldCreatedEnvelope, "wix.contacts.v4.extended-field_created">;
-declare const onExtendedFieldUpdated$1: EventDefinition<ExtendedFieldUpdatedEnvelope, "wix.contacts.v4.extended-field_updated">;
-declare const onExtendedFieldDeleted$1: EventDefinition<ExtendedFieldDeletedEnvelope, "wix.contacts.v4.extended-field_deleted">;
+declare const onExtendedFieldCreated$1: EventDefinition$3<ExtendedFieldCreatedEnvelope, "wix.contacts.v4.extended-field_created">;
+declare const onExtendedFieldUpdated$1: EventDefinition$3<ExtendedFieldUpdatedEnvelope, "wix.contacts.v4.extended-field_updated">;
+declare const onExtendedFieldDeleted$1: EventDefinition$3<ExtendedFieldDeletedEnvelope, "wix.contacts.v4.extended-field_deleted">;
+
+declare function createEventModule$2<T extends EventDefinition$3<any, string>>(eventDefinition: T): BuildEventDefinition$3<T> & T;
+
+declare const findOrCreateExtendedField: MaybeContext$3<BuildRESTFunction$3<typeof findOrCreateExtendedField$1> & typeof findOrCreateExtendedField$1>;
+declare const getExtendedField: MaybeContext$3<BuildRESTFunction$3<typeof getExtendedField$1> & typeof getExtendedField$1>;
+declare const renameExtendedField: MaybeContext$3<BuildRESTFunction$3<typeof renameExtendedField$1> & typeof renameExtendedField$1>;
+declare const deleteExtendedField: MaybeContext$3<BuildRESTFunction$3<typeof deleteExtendedField$1> & typeof deleteExtendedField$1>;
+declare const queryExtendedFields: MaybeContext$3<BuildRESTFunction$3<typeof queryExtendedFields$1> & typeof queryExtendedFields$1>;
+
+type _publicOnExtendedFieldCreatedType = typeof onExtendedFieldCreated$1;
+/**
+ * Triggered when an extended field is created.
+ */
+declare const onExtendedFieldCreated: ReturnType<typeof createEventModule$2<_publicOnExtendedFieldCreatedType>>;
+
+type _publicOnExtendedFieldUpdatedType = typeof onExtendedFieldUpdated$1;
+/**
+ * Triggered when an extended field is updated.
+ */
+declare const onExtendedFieldUpdated: ReturnType<typeof createEventModule$2<_publicOnExtendedFieldUpdatedType>>;
+
+type _publicOnExtendedFieldDeletedType = typeof onExtendedFieldDeleted$1;
+/**
+ * Triggered when an extended field is deleted.
+ */
+declare const onExtendedFieldDeleted: ReturnType<typeof createEventModule$2<_publicOnExtendedFieldDeletedType>>;
+
+type context$3_DeleteExtendedFieldRequest = DeleteExtendedFieldRequest;
+type context$3_DeleteExtendedFieldResponse = DeleteExtendedFieldResponse;
+type context$3_ExtendedField = ExtendedField;
+type context$3_ExtendedFieldCreatedEnvelope = ExtendedFieldCreatedEnvelope;
+type context$3_ExtendedFieldDeletedEnvelope = ExtendedFieldDeletedEnvelope;
+type context$3_ExtendedFieldNonNullableFields = ExtendedFieldNonNullableFields;
+type context$3_ExtendedFieldUpdatedEnvelope = ExtendedFieldUpdatedEnvelope;
+type context$3_FieldDataType = FieldDataType;
+declare const context$3_FieldDataType: typeof FieldDataType;
+type context$3_FieldType = FieldType;
+declare const context$3_FieldType: typeof FieldType;
+type context$3_FieldsQueryBuilder = FieldsQueryBuilder;
+type context$3_FieldsQueryResult = FieldsQueryResult;
+type context$3_FindOrCreateExtendedFieldRequest = FindOrCreateExtendedFieldRequest;
+type context$3_FindOrCreateExtendedFieldResponse = FindOrCreateExtendedFieldResponse;
+type context$3_FindOrCreateExtendedFieldResponseNonNullableFields = FindOrCreateExtendedFieldResponseNonNullableFields;
+type context$3_GetExtendedFieldByLegacyIdRequest = GetExtendedFieldByLegacyIdRequest;
+type context$3_GetExtendedFieldByLegacyIdResponse = GetExtendedFieldByLegacyIdResponse;
+type context$3_GetExtendedFieldRequest = GetExtendedFieldRequest;
+type context$3_GetExtendedFieldResponse = GetExtendedFieldResponse;
+type context$3_GetExtendedFieldResponseNonNullableFields = GetExtendedFieldResponseNonNullableFields;
+type context$3_ListExtendedFieldsRequest = ListExtendedFieldsRequest;
+type context$3_ListExtendedFieldsResponse = ListExtendedFieldsResponse;
+type context$3_QueryExtendedFieldsRequest = QueryExtendedFieldsRequest;
+type context$3_QueryExtendedFieldsResponse = QueryExtendedFieldsResponse;
+type context$3_QueryExtendedFieldsResponseNonNullableFields = QueryExtendedFieldsResponseNonNullableFields;
+type context$3_RenameExtendedField = RenameExtendedField;
+type context$3_UpdateExtendedFieldRequest = UpdateExtendedFieldRequest;
+type context$3_UpdateExtendedFieldResponse = UpdateExtendedFieldResponse;
+type context$3_UpdateExtendedFieldResponseNonNullableFields = UpdateExtendedFieldResponseNonNullableFields;
+type context$3__publicOnExtendedFieldCreatedType = _publicOnExtendedFieldCreatedType;
+type context$3__publicOnExtendedFieldDeletedType = _publicOnExtendedFieldDeletedType;
+type context$3__publicOnExtendedFieldUpdatedType = _publicOnExtendedFieldUpdatedType;
+declare const context$3_deleteExtendedField: typeof deleteExtendedField;
+declare const context$3_findOrCreateExtendedField: typeof findOrCreateExtendedField;
+declare const context$3_getExtendedField: typeof getExtendedField;
+declare const context$3_onExtendedFieldCreated: typeof onExtendedFieldCreated;
+declare const context$3_onExtendedFieldDeleted: typeof onExtendedFieldDeleted;
+declare const context$3_onExtendedFieldUpdated: typeof onExtendedFieldUpdated;
+declare const context$3_queryExtendedFields: typeof queryExtendedFields;
+declare const context$3_renameExtendedField: typeof renameExtendedField;
+declare namespace context$3 {
+  export { type ActionEvent$2 as ActionEvent, type BaseEventMetadata$2 as BaseEventMetadata, type context$3_DeleteExtendedFieldRequest as DeleteExtendedFieldRequest, type context$3_DeleteExtendedFieldResponse as DeleteExtendedFieldResponse, type DomainEvent$2 as DomainEvent, type DomainEventBodyOneOf$2 as DomainEventBodyOneOf, type EntityCreatedEvent$2 as EntityCreatedEvent, type EntityDeletedEvent$2 as EntityDeletedEvent, type EntityUpdatedEvent$2 as EntityUpdatedEvent, type EventMetadata$2 as EventMetadata, type context$3_ExtendedField as ExtendedField, type context$3_ExtendedFieldCreatedEnvelope as ExtendedFieldCreatedEnvelope, type context$3_ExtendedFieldDeletedEnvelope as ExtendedFieldDeletedEnvelope, type context$3_ExtendedFieldNonNullableFields as ExtendedFieldNonNullableFields, type context$3_ExtendedFieldUpdatedEnvelope as ExtendedFieldUpdatedEnvelope, context$3_FieldDataType as FieldDataType, context$3_FieldType as FieldType, type context$3_FieldsQueryBuilder as FieldsQueryBuilder, type context$3_FieldsQueryResult as FieldsQueryResult, type context$3_FindOrCreateExtendedFieldRequest as FindOrCreateExtendedFieldRequest, type context$3_FindOrCreateExtendedFieldResponse as FindOrCreateExtendedFieldResponse, type context$3_FindOrCreateExtendedFieldResponseNonNullableFields as FindOrCreateExtendedFieldResponseNonNullableFields, type GdprListRequest$1 as GdprListRequest, type GdprListResponse$1 as GdprListResponse, type context$3_GetExtendedFieldByLegacyIdRequest as GetExtendedFieldByLegacyIdRequest, type context$3_GetExtendedFieldByLegacyIdResponse as GetExtendedFieldByLegacyIdResponse, type context$3_GetExtendedFieldRequest as GetExtendedFieldRequest, type context$3_GetExtendedFieldResponse as GetExtendedFieldResponse, type context$3_GetExtendedFieldResponseNonNullableFields as GetExtendedFieldResponseNonNullableFields, type IdentificationData$3 as IdentificationData, type IdentificationDataIdOneOf$3 as IdentificationDataIdOneOf, type context$3_ListExtendedFieldsRequest as ListExtendedFieldsRequest, type context$3_ListExtendedFieldsResponse as ListExtendedFieldsResponse, type MessageEnvelope$3 as MessageEnvelope, type Paging$2 as Paging, type PagingMetadata$1 as PagingMetadata, type PurgeRequest$1 as PurgeRequest, type PurgeResponse$1 as PurgeResponse, type Query$1 as Query, type context$3_QueryExtendedFieldsRequest as QueryExtendedFieldsRequest, type context$3_QueryExtendedFieldsResponse as QueryExtendedFieldsResponse, type context$3_QueryExtendedFieldsResponseNonNullableFields as QueryExtendedFieldsResponseNonNullableFields, type context$3_RenameExtendedField as RenameExtendedField, type RestoreInfo$1 as RestoreInfo, SortOrder$2 as SortOrder, type Sorting$2 as Sorting, type context$3_UpdateExtendedFieldRequest as UpdateExtendedFieldRequest, type context$3_UpdateExtendedFieldResponse as UpdateExtendedFieldResponse, type context$3_UpdateExtendedFieldResponseNonNullableFields as UpdateExtendedFieldResponseNonNullableFields, WebhookIdentityType$3 as WebhookIdentityType, type context$3__publicOnExtendedFieldCreatedType as _publicOnExtendedFieldCreatedType, type context$3__publicOnExtendedFieldDeletedType as _publicOnExtendedFieldDeletedType, type context$3__publicOnExtendedFieldUpdatedType as _publicOnExtendedFieldUpdatedType, context$3_deleteExtendedField as deleteExtendedField, context$3_findOrCreateExtendedField as findOrCreateExtendedField, context$3_getExtendedField as getExtendedField, context$3_onExtendedFieldCreated as onExtendedFieldCreated, context$3_onExtendedFieldDeleted as onExtendedFieldDeleted, context$3_onExtendedFieldUpdated as onExtendedFieldUpdated, onExtendedFieldCreated$1 as publicOnExtendedFieldCreated, onExtendedFieldDeleted$1 as publicOnExtendedFieldDeleted, onExtendedFieldUpdated$1 as publicOnExtendedFieldUpdated, context$3_queryExtendedFields as queryExtendedFields, context$3_renameExtendedField as renameExtendedField };
+}
+
+type HostModule$2<T, H extends Host$2> = {
+    __type: 'host';
+    create(host: H): T;
+};
+type HostModuleAPI$2<T extends HostModule$2<any, any>> = T extends HostModule$2<infer U, any> ? U : never;
+type Host$2<Environment = unknown> = {
+    channel: {
+        observeState(callback: (props: unknown, environment: Environment) => unknown): {
+            disconnect: () => void;
+        } | Promise<{
+            disconnect: () => void;
+        }>;
+    };
+    environment?: Environment;
+    /**
+     * Optional name of the environment, use for logging
+     */
+    name?: string;
+    /**
+     * Optional bast url to use for API requests, for example `www.wixapis.com`
+     */
+    apiBaseUrl?: string;
+    /**
+     * Possible data to be provided by every host, for cross cutting concerns
+     * like internationalization, billing, etc.
+     */
+    essentials?: {
+        /**
+         * The language of the currently viewed session
+         */
+        language?: string;
+        /**
+         * The locale of the currently viewed session
+         */
+        locale?: string;
+        /**
+         * Any headers that should be passed through to the API requests
+         */
+        passThroughHeaders?: Record<string, string>;
+    };
+};
+
+type RESTFunctionDescriptor$2<T extends (...args: any[]) => any = (...args: any[]) => any> = (httpClient: HttpClient$2) => T;
+interface HttpClient$2 {
+    request<TResponse, TData = any>(req: RequestOptionsFactory$2<TResponse, TData>): Promise<HttpResponse$2<TResponse>>;
+    fetchWithAuth: typeof fetch;
+    wixAPIFetch: (relativeUrl: string, options: RequestInit) => Promise<Response>;
+    getActiveToken?: () => string | undefined;
+}
+type RequestOptionsFactory$2<TResponse = any, TData = any> = (context: any) => RequestOptions$2<TResponse, TData>;
+type HttpResponse$2<T = any> = {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: any;
+    request?: any;
+};
+type RequestOptions$2<_TResponse = any, Data = any> = {
+    method: 'POST' | 'GET' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+    url: string;
+    data?: Data;
+    params?: URLSearchParams;
+} & APIMetadata$2;
+type APIMetadata$2 = {
+    methodFqn?: string;
+    entityFqdn?: string;
+    packageName?: string;
+};
+type BuildRESTFunction$2<T extends RESTFunctionDescriptor$2> = T extends RESTFunctionDescriptor$2<infer U> ? U : never;
+type EventDefinition$2<Payload = unknown, Type extends string = string> = {
+    __type: 'event-definition';
+    type: Type;
+    isDomainEvent?: boolean;
+    transformations?: (envelope: unknown) => Payload;
+    __payload: Payload;
+};
+declare function EventDefinition$2<Type extends string>(type: Type, isDomainEvent?: boolean, transformations?: (envelope: any) => unknown): <Payload = unknown>() => EventDefinition$2<Payload, Type>;
+type EventHandler$2<T extends EventDefinition$2> = (payload: T['__payload']) => void | Promise<void>;
+type BuildEventDefinition$2<T extends EventDefinition$2<any, string>> = (handler: EventHandler$2<T>) => void;
+
+type ServicePluginMethodInput$2 = {
+    request: any;
+    metadata: any;
+};
+type ServicePluginContract$2 = Record<string, (payload: ServicePluginMethodInput$2) => unknown | Promise<unknown>>;
+type ServicePluginMethodMetadata$2 = {
+    name: string;
+    primaryHttpMappingPath: string;
+    transformations: {
+        fromREST: (...args: unknown[]) => ServicePluginMethodInput$2;
+        toREST: (...args: unknown[]) => unknown;
+    };
+};
+type ServicePluginDefinition$2<Contract extends ServicePluginContract$2> = {
+    __type: 'service-plugin-definition';
+    componentType: string;
+    methods: ServicePluginMethodMetadata$2[];
+    __contract: Contract;
+};
+declare function ServicePluginDefinition$2<Contract extends ServicePluginContract$2>(componentType: string, methods: ServicePluginMethodMetadata$2[]): ServicePluginDefinition$2<Contract>;
+type BuildServicePluginDefinition$2<T extends ServicePluginDefinition$2<any>> = (implementation: T['__contract']) => void;
+declare const SERVICE_PLUGIN_ERROR_TYPE$2 = "wix_spi_error";
+
+type RequestContext$2 = {
+    isSSR: boolean;
+    host: string;
+    protocol?: string;
+};
+type ResponseTransformer$2 = (data: any, headers?: any) => any;
+/**
+ * Ambassador request options types are copied mostly from AxiosRequestConfig.
+ * They are copied and not imported to reduce the amount of dependencies (to reduce install time).
+ * https://github.com/axios/axios/blob/3f53eb6960f05a1f88409c4b731a40de595cb825/index.d.ts#L307-L315
+ */
+type Method$2 = 'get' | 'GET' | 'delete' | 'DELETE' | 'head' | 'HEAD' | 'options' | 'OPTIONS' | 'post' | 'POST' | 'put' | 'PUT' | 'patch' | 'PATCH' | 'purge' | 'PURGE' | 'link' | 'LINK' | 'unlink' | 'UNLINK';
+type AmbassadorRequestOptions$2<T = any> = {
+    _?: T;
+    url?: string;
+    method?: Method$2;
+    params?: any;
+    data?: any;
+    transformResponse?: ResponseTransformer$2 | ResponseTransformer$2[];
+};
+type AmbassadorFactory$2<Request, Response> = (payload: Request) => ((context: RequestContext$2) => AmbassadorRequestOptions$2<Response>) & {
+    __isAmbassador: boolean;
+};
+type AmbassadorFunctionDescriptor$2<Request = any, Response = any> = AmbassadorFactory$2<Request, Response>;
+type BuildAmbassadorFunction$2<T extends AmbassadorFunctionDescriptor$2> = T extends AmbassadorFunctionDescriptor$2<infer Request, infer Response> ? (req: Request) => Promise<Response> : never;
+
+declare global {
+	// eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
+	interface SymbolConstructor {
+		readonly observable: symbol;
+	}
+}
+
+declare const emptyObjectSymbol$2: unique symbol;
+
+/**
+Represents a strictly empty plain object, the `{}` value.
+
+When you annotate something as the type `{}`, it can be anything except `null` and `undefined`. This means that you cannot use `{}` to represent an empty plain object ([read more](https://stackoverflow.com/questions/47339869/typescript-empty-object-and-any-difference/52193484#52193484)).
+
+@example
+```
+import type {EmptyObject} from 'type-fest';
+
+// The following illustrates the problem with `{}`.
+const foo1: {} = {}; // Pass
+const foo2: {} = []; // Pass
+const foo3: {} = 42; // Pass
+const foo4: {} = {a: 1}; // Pass
+
+// With `EmptyObject` only the first case is valid.
+const bar1: EmptyObject = {}; // Pass
+const bar2: EmptyObject = 42; // Fail
+const bar3: EmptyObject = []; // Fail
+const bar4: EmptyObject = {a: 1}; // Fail
+```
+
+Unfortunately, `Record<string, never>`, `Record<keyof any, never>` and `Record<never, never>` do not work. See {@link https://github.com/sindresorhus/type-fest/issues/395 #395}.
+
+@category Object
+*/
+type EmptyObject$2 = {[emptyObjectSymbol$2]?: never};
+
+/**
+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$2<A, B> =
+	(<G>() => G extends A ? 1 : 2) extends
+	(<G>() => G extends B ? 1 : 2)
+		? true
+		: false;
+
+/**
+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$2<KeyType, ExcludeType> = IsEqual$2<KeyType, ExcludeType> extends true ? never : (KeyType extends ExcludeType ? never : KeyType);
+
+type ExceptOptions$2 = {
+	/**
+	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;
+};
+
+/**
+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}
+
+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>>
+
+const fooWithoutB: FooWithoutB = {a: 1, b: '2'};
+//=> errors at 'b': Type 'string' is not assignable to type 'undefined'.
+```
+
+@category Object
+*/
+type Except$2<ObjectType, KeysType extends keyof ObjectType, Options extends ExceptOptions$2 = {requireExactProps: false}> = {
+	[KeyType in keyof ObjectType as Filter$2<KeyType, KeysType>]: ObjectType[KeyType];
+} & (Options['requireExactProps'] extends true
+	? Partial<Record<KeysType, never>>
+	: {});
+
+/**
+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';
+
+// https://github.com/andnp/SimplyTyped/blob/master/src/types/strings.ts
+type AreStringsEqual<A extends string, B extends string> =
+	And<
+		IsNever<Exclude<A, B>> extends true ? true : false,
+		IsNever<Exclude<B, A>> extends true ? true : false
+	>;
+
+type EndIfEqual<I extends string, O extends string> =
+	AreStringsEqual<I, O> extends true
+		? never
+		: void;
+
+function endIfEqual<I extends string, O extends string>(input: I, output: O): EndIfEqual<I, O> {
+	if (input === output) {
+		process.exit(0);
+	}
+}
+
+endIfEqual('abc', 'abc');
+//=> never
+
+endIfEqual('abc', '123');
+//=> void
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsNever$2<T> = [T] extends [never] ? true : false;
+
+/**
+An if-else-like type that resolves depending on whether the given type is `never`.
+
+@see {@link IsNever}
+
+@example
+```
+import type {IfNever} from 'type-fest';
+
+type ShouldBeTrue = IfNever<never>;
+//=> true
+
+type ShouldBeBar = IfNever<'not never', 'foo', 'bar'>;
+//=> 'bar'
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IfNever$2<T, TypeIfNever = true, TypeIfNotNever = false> = (
+	IsNever$2<T> extends true ? TypeIfNever : TypeIfNotNever
+);
+
+/**
+Extract the keys from a type where the value type of the key extends the given `Condition`.
+
+Internally this is used for the `ConditionalPick` and `ConditionalExcept` types.
+
+@example
+```
+import type {ConditionalKeys} from 'type-fest';
+
+interface Example {
+	a: string;
+	b: string | number;
+	c?: string;
+	d: {};
+}
 
-declare function createEventModule$2<T extends EventDefinition<any, string>>(eventDefinition: T): BuildEventDefinition<T> & T;
+type StringKeysOnly = ConditionalKeys<Example, string>;
+//=> 'a'
+```
 
-declare const findOrCreateExtendedField: BuildRESTFunction<typeof findOrCreateExtendedField$1> & typeof findOrCreateExtendedField$1;
-declare const getExtendedField: BuildRESTFunction<typeof getExtendedField$1> & typeof getExtendedField$1;
-declare const renameExtendedField: BuildRESTFunction<typeof renameExtendedField$1> & typeof renameExtendedField$1;
-declare const deleteExtendedField: BuildRESTFunction<typeof deleteExtendedField$1> & typeof deleteExtendedField$1;
-declare const queryExtendedFields: BuildRESTFunction<typeof queryExtendedFields$1> & typeof queryExtendedFields$1;
+To support partial types, make sure your `Condition` is a union of undefined (for example, `string | undefined`) as demonstrated below.
+
+@example
+```
+import type {ConditionalKeys} from 'type-fest';
+
+type StringKeysAndUndefined = ConditionalKeys<Example, string | undefined>;
+//=> 'a' | 'c'
+```
+
+@category Object
+*/
+type ConditionalKeys$2<Base, Condition> =
+{
+	// Map through all the keys of the given base type.
+	[Key in keyof Base]-?:
+	// Pick only keys with types extending the given `Condition` type.
+	Base[Key] extends Condition
+	// Retain this key
+	// If the value for the key extends never, only include it if `Condition` also extends never
+		? IfNever$2<Base[Key], IfNever$2<Condition, Key, never>, Key>
+	// Discard this key since the condition fails.
+		: never;
+	// Convert the produced object into a union type of the keys which passed the conditional test.
+}[keyof Base];
 
-type _publicOnExtendedFieldCreatedType = typeof onExtendedFieldCreated$1;
 /**
- * Triggered when an extended field is created.
- */
-declare const onExtendedFieldCreated: ReturnType<typeof createEventModule$2<_publicOnExtendedFieldCreatedType>>;
+Exclude keys from a shape that matches the given `Condition`.
+
+This is useful when you want to create a new type with a specific set of keys from a shape. For example, you might want to exclude all the primitive properties from a class and form a new shape containing everything but the primitive properties.
+
+@example
+```
+import type {Primitive, ConditionalExcept} from 'type-fest';
+
+class Awesome {
+	name: string;
+	successes: number;
+	failures: bigint;
+
+	run() {}
+}
+
+type ExceptPrimitivesFromAwesome = ConditionalExcept<Awesome, Primitive>;
+//=> {run: () => void}
+```
+
+@example
+```
+import type {ConditionalExcept} from 'type-fest';
+
+interface Example {
+	a: string;
+	b: string | number;
+	c: () => void;
+	d: {};
+}
+
+type NonStringKeysOnly = ConditionalExcept<Example, string>;
+//=> {b: string | number; c: () => void; d: {}}
+```
+
+@category Object
+*/
+type ConditionalExcept$2<Base, Condition> = Except$2<
+Base,
+ConditionalKeys$2<Base, Condition>
+>;
 
-type _publicOnExtendedFieldUpdatedType = typeof onExtendedFieldUpdated$1;
 /**
- * Triggered when an extended field is updated.
+ * Descriptors are objects that describe the API of a module, and the module
+ * can either be a REST module or a host module.
+ * This type is recursive, so it can describe nested modules.
  */
-declare const onExtendedFieldUpdated: ReturnType<typeof createEventModule$2<_publicOnExtendedFieldUpdatedType>>;
-
-type _publicOnExtendedFieldDeletedType = typeof onExtendedFieldDeleted$1;
+type Descriptors$2 = RESTFunctionDescriptor$2 | AmbassadorFunctionDescriptor$2 | HostModule$2<any, any> | EventDefinition$2<any> | ServicePluginDefinition$2<any> | {
+    [key: string]: Descriptors$2 | PublicMetadata$2 | any;
+};
 /**
- * Triggered when an extended field is deleted.
+ * This type takes in a descriptors object of a certain Host (including an `unknown` host)
+ * and returns an object with the same structure, but with all descriptors replaced with their API.
+ * Any non-descriptor properties are removed from the returned object, including descriptors that
+ * do not match the given host (as they will not work with the given host).
  */
-declare const onExtendedFieldDeleted: ReturnType<typeof createEventModule$2<_publicOnExtendedFieldDeletedType>>;
+type BuildDescriptors$2<T extends Descriptors$2, H extends Host$2<any> | undefined, Depth extends number = 5> = {
+    done: T;
+    recurse: T extends {
+        __type: typeof SERVICE_PLUGIN_ERROR_TYPE$2;
+    } ? never : T extends AmbassadorFunctionDescriptor$2 ? BuildAmbassadorFunction$2<T> : T extends RESTFunctionDescriptor$2 ? BuildRESTFunction$2<T> : T extends EventDefinition$2<any> ? BuildEventDefinition$2<T> : T extends ServicePluginDefinition$2<any> ? BuildServicePluginDefinition$2<T> : T extends HostModule$2<any, any> ? HostModuleAPI$2<T> : ConditionalExcept$2<{
+        [Key in keyof T]: T[Key] extends Descriptors$2 ? BuildDescriptors$2<T[Key], H, [
+            -1,
+            0,
+            1,
+            2,
+            3,
+            4,
+            5
+        ][Depth]> : never;
+    }, EmptyObject$2>;
+}[Depth extends -1 ? 'done' : 'recurse'];
+type PublicMetadata$2 = {
+    PACKAGE_NAME?: string;
+};
 
-type context$3_DeleteExtendedFieldRequest = DeleteExtendedFieldRequest;
-type context$3_DeleteExtendedFieldResponse = DeleteExtendedFieldResponse;
-type context$3_ExtendedField = ExtendedField;
-type context$3_ExtendedFieldCreatedEnvelope = ExtendedFieldCreatedEnvelope;
-type context$3_ExtendedFieldDeletedEnvelope = ExtendedFieldDeletedEnvelope;
-type context$3_ExtendedFieldNonNullableFields = ExtendedFieldNonNullableFields;
-type context$3_ExtendedFieldUpdatedEnvelope = ExtendedFieldUpdatedEnvelope;
-type context$3_FieldDataType = FieldDataType;
-declare const context$3_FieldDataType: typeof FieldDataType;
-type context$3_FieldType = FieldType;
-declare const context$3_FieldType: typeof FieldType;
-type context$3_FieldsQueryBuilder = FieldsQueryBuilder;
-type context$3_FieldsQueryResult = FieldsQueryResult;
-type context$3_FindOrCreateExtendedFieldRequest = FindOrCreateExtendedFieldRequest;
-type context$3_FindOrCreateExtendedFieldResponse = FindOrCreateExtendedFieldResponse;
-type context$3_FindOrCreateExtendedFieldResponseNonNullableFields = FindOrCreateExtendedFieldResponseNonNullableFields;
-type context$3_GetExtendedFieldByLegacyIdRequest = GetExtendedFieldByLegacyIdRequest;
-type context$3_GetExtendedFieldByLegacyIdResponse = GetExtendedFieldByLegacyIdResponse;
-type context$3_GetExtendedFieldRequest = GetExtendedFieldRequest;
-type context$3_GetExtendedFieldResponse = GetExtendedFieldResponse;
-type context$3_GetExtendedFieldResponseNonNullableFields = GetExtendedFieldResponseNonNullableFields;
-type context$3_ListExtendedFieldsRequest = ListExtendedFieldsRequest;
-type context$3_ListExtendedFieldsResponse = ListExtendedFieldsResponse;
-type context$3_QueryExtendedFieldsRequest = QueryExtendedFieldsRequest;
-type context$3_QueryExtendedFieldsResponse = QueryExtendedFieldsResponse;
-type context$3_QueryExtendedFieldsResponseNonNullableFields = QueryExtendedFieldsResponseNonNullableFields;
-type context$3_RenameExtendedField = RenameExtendedField;
-type context$3_UpdateExtendedFieldRequest = UpdateExtendedFieldRequest;
-type context$3_UpdateExtendedFieldResponse = UpdateExtendedFieldResponse;
-type context$3_UpdateExtendedFieldResponseNonNullableFields = UpdateExtendedFieldResponseNonNullableFields;
-type context$3__publicOnExtendedFieldCreatedType = _publicOnExtendedFieldCreatedType;
-type context$3__publicOnExtendedFieldDeletedType = _publicOnExtendedFieldDeletedType;
-type context$3__publicOnExtendedFieldUpdatedType = _publicOnExtendedFieldUpdatedType;
-declare const context$3_deleteExtendedField: typeof deleteExtendedField;
-declare const context$3_findOrCreateExtendedField: typeof findOrCreateExtendedField;
-declare const context$3_getExtendedField: typeof getExtendedField;
-declare const context$3_onExtendedFieldCreated: typeof onExtendedFieldCreated;
-declare const context$3_onExtendedFieldDeleted: typeof onExtendedFieldDeleted;
-declare const context$3_onExtendedFieldUpdated: typeof onExtendedFieldUpdated;
-declare const context$3_queryExtendedFields: typeof queryExtendedFields;
-declare const context$3_renameExtendedField: typeof renameExtendedField;
-declare namespace context$3 {
-  export { type ActionEvent$2 as ActionEvent, type BaseEventMetadata$2 as BaseEventMetadata, type context$3_DeleteExtendedFieldRequest as DeleteExtendedFieldRequest, type context$3_DeleteExtendedFieldResponse as DeleteExtendedFieldResponse, type DomainEvent$2 as DomainEvent, type DomainEventBodyOneOf$2 as DomainEventBodyOneOf, type EntityCreatedEvent$2 as EntityCreatedEvent, type EntityDeletedEvent$2 as EntityDeletedEvent, type EntityUpdatedEvent$2 as EntityUpdatedEvent, type EventMetadata$2 as EventMetadata, type context$3_ExtendedField as ExtendedField, type context$3_ExtendedFieldCreatedEnvelope as ExtendedFieldCreatedEnvelope, type context$3_ExtendedFieldDeletedEnvelope as ExtendedFieldDeletedEnvelope, type context$3_ExtendedFieldNonNullableFields as ExtendedFieldNonNullableFields, type context$3_ExtendedFieldUpdatedEnvelope as ExtendedFieldUpdatedEnvelope, context$3_FieldDataType as FieldDataType, context$3_FieldType as FieldType, type context$3_FieldsQueryBuilder as FieldsQueryBuilder, type context$3_FieldsQueryResult as FieldsQueryResult, type context$3_FindOrCreateExtendedFieldRequest as FindOrCreateExtendedFieldRequest, type context$3_FindOrCreateExtendedFieldResponse as FindOrCreateExtendedFieldResponse, type context$3_FindOrCreateExtendedFieldResponseNonNullableFields as FindOrCreateExtendedFieldResponseNonNullableFields, type GdprListRequest$1 as GdprListRequest, type GdprListResponse$1 as GdprListResponse, type context$3_GetExtendedFieldByLegacyIdRequest as GetExtendedFieldByLegacyIdRequest, type context$3_GetExtendedFieldByLegacyIdResponse as GetExtendedFieldByLegacyIdResponse, type context$3_GetExtendedFieldRequest as GetExtendedFieldRequest, type context$3_GetExtendedFieldResponse as GetExtendedFieldResponse, type context$3_GetExtendedFieldResponseNonNullableFields as GetExtendedFieldResponseNonNullableFields, type IdentificationData$3 as IdentificationData, type IdentificationDataIdOneOf$3 as IdentificationDataIdOneOf, type context$3_ListExtendedFieldsRequest as ListExtendedFieldsRequest, type context$3_ListExtendedFieldsResponse as ListExtendedFieldsResponse, type MessageEnvelope$3 as MessageEnvelope, type Paging$2 as Paging, type PagingMetadata$1 as PagingMetadata, type PurgeRequest$1 as PurgeRequest, type PurgeResponse$1 as PurgeResponse, type Query$1 as Query, type context$3_QueryExtendedFieldsRequest as QueryExtendedFieldsRequest, type context$3_QueryExtendedFieldsResponse as QueryExtendedFieldsResponse, type context$3_QueryExtendedFieldsResponseNonNullableFields as QueryExtendedFieldsResponseNonNullableFields, type context$3_RenameExtendedField as RenameExtendedField, type RestoreInfo$1 as RestoreInfo, SortOrder$2 as SortOrder, type Sorting$2 as Sorting, type context$3_UpdateExtendedFieldRequest as UpdateExtendedFieldRequest, type context$3_UpdateExtendedFieldResponse as UpdateExtendedFieldResponse, type context$3_UpdateExtendedFieldResponseNonNullableFields as UpdateExtendedFieldResponseNonNullableFields, WebhookIdentityType$3 as WebhookIdentityType, type context$3__publicOnExtendedFieldCreatedType as _publicOnExtendedFieldCreatedType, type context$3__publicOnExtendedFieldDeletedType as _publicOnExtendedFieldDeletedType, type context$3__publicOnExtendedFieldUpdatedType as _publicOnExtendedFieldUpdatedType, context$3_deleteExtendedField as deleteExtendedField, context$3_findOrCreateExtendedField as findOrCreateExtendedField, context$3_getExtendedField as getExtendedField, context$3_onExtendedFieldCreated as onExtendedFieldCreated, context$3_onExtendedFieldDeleted as onExtendedFieldDeleted, context$3_onExtendedFieldUpdated as onExtendedFieldUpdated, onExtendedFieldCreated$1 as publicOnExtendedFieldCreated, onExtendedFieldDeleted$1 as publicOnExtendedFieldDeleted, onExtendedFieldUpdated$1 as publicOnExtendedFieldUpdated, context$3_queryExtendedFields as queryExtendedFields, context$3_renameExtendedField as renameExtendedField };
+declare global {
+    interface ContextualClient {
+    }
 }
+/**
+ * A type used to create concerete types from SDK descriptors in
+ * case a contextual client is available.
+ */
+type MaybeContext$2<T extends Descriptors$2> = globalThis.ContextualClient extends {
+    host: Host$2;
+} ? BuildDescriptors$2<T, globalThis.ContextualClient['host']> : T;
 
 /** Label that was found or created. */
 interface ContactLabel {
@@ -4147,7 +6015,7 @@ interface LabelsQueryBuilder {
     find: () => Promise<LabelsQueryResult>;
 }
 
-declare function findOrCreateLabel$1(httpClient: HttpClient): FindOrCreateLabelSignature;
+declare function findOrCreateLabel$1(httpClient: HttpClient$2): FindOrCreateLabelSignature;
 interface FindOrCreateLabelSignature {
     /**
      * Retrieves a label with a given name, or creates one if it doesn't exist.
@@ -4170,7 +6038,7 @@ interface FindOrCreateLabelSignature {
      */
     (displayName: string, options?: FindOrCreateLabelOptions | undefined): Promise<FindOrCreateLabelResponse & FindOrCreateLabelResponseNonNullableFields>;
 }
-declare function getLabel$1(httpClient: HttpClient): GetLabelSignature;
+declare function getLabel$1(httpClient: HttpClient$2): GetLabelSignature;
 interface GetLabelSignature {
     /**
      * Retrieves a label by the specified label key.
@@ -4185,7 +6053,7 @@ interface GetLabelSignature {
      */
     (key: string, options?: GetLabelOptions | undefined): Promise<ContactLabel & ContactLabelNonNullableFields>;
 }
-declare function renameLabel$1(httpClient: HttpClient): RenameLabelSignature;
+declare function renameLabel$1(httpClient: HttpClient$2): RenameLabelSignature;
 interface RenameLabelSignature {
     /**
      * Renames a label.
@@ -4202,7 +6070,7 @@ interface RenameLabelSignature {
      */
     (key: string, label: RenameLabel, options?: RenameLabelOptions | undefined): Promise<ContactLabel & ContactLabelNonNullableFields>;
 }
-declare function deleteLabel$1(httpClient: HttpClient): DeleteLabelSignature;
+declare function deleteLabel$1(httpClient: HttpClient$2): DeleteLabelSignature;
 interface DeleteLabelSignature {
     /**
      * Deletes a label from the site and removes it from contacts it applies to.
@@ -4214,7 +6082,7 @@ interface DeleteLabelSignature {
      */
     (key: string): Promise<void>;
 }
-declare function queryLabels$1(httpClient: HttpClient): QueryLabelsSignature;
+declare function queryLabels$1(httpClient: HttpClient$2): QueryLabelsSignature;
 interface QueryLabelsSignature {
     /**
      * Creates a query to retrieve a list of labels.
@@ -4237,93 +6105,571 @@ interface QueryLabelsSignature {
      */
     (options?: QueryLabelsOptions | undefined): LabelsQueryBuilder;
 }
-declare const onLabelCreated$1: EventDefinition<LabelCreatedEnvelope, "wix.contacts.v4.label_created">;
-declare const onLabelUpdated$1: EventDefinition<LabelUpdatedEnvelope, "wix.contacts.v4.label_updated">;
-declare const onLabelDeleted$1: EventDefinition<LabelDeletedEnvelope, "wix.contacts.v4.label_deleted">;
+declare const onLabelCreated$1: EventDefinition$2<LabelCreatedEnvelope, "wix.contacts.v4.label_created">;
+declare const onLabelUpdated$1: EventDefinition$2<LabelUpdatedEnvelope, "wix.contacts.v4.label_updated">;
+declare const onLabelDeleted$1: EventDefinition$2<LabelDeletedEnvelope, "wix.contacts.v4.label_deleted">;
+
+declare function createEventModule$1<T extends EventDefinition$2<any, string>>(eventDefinition: T): BuildEventDefinition$2<T> & T;
+
+declare const findOrCreateLabel: MaybeContext$2<BuildRESTFunction$2<typeof findOrCreateLabel$1> & typeof findOrCreateLabel$1>;
+declare const getLabel: MaybeContext$2<BuildRESTFunction$2<typeof getLabel$1> & typeof getLabel$1>;
+declare const renameLabel: MaybeContext$2<BuildRESTFunction$2<typeof renameLabel$1> & typeof renameLabel$1>;
+declare const deleteLabel: MaybeContext$2<BuildRESTFunction$2<typeof deleteLabel$1> & typeof deleteLabel$1>;
+declare const queryLabels: MaybeContext$2<BuildRESTFunction$2<typeof queryLabels$1> & typeof queryLabels$1>;
+
+type _publicOnLabelCreatedType = typeof onLabelCreated$1;
+/**
+ * Triggered when a label is created.
+ */
+declare const onLabelCreated: ReturnType<typeof createEventModule$1<_publicOnLabelCreatedType>>;
+
+type _publicOnLabelUpdatedType = typeof onLabelUpdated$1;
+/**
+ * Triggered when a label is updated.
+ */
+declare const onLabelUpdated: ReturnType<typeof createEventModule$1<_publicOnLabelUpdatedType>>;
+
+type _publicOnLabelDeletedType = typeof onLabelDeleted$1;
+/**
+ * Triggered when a label is deleted.
+ */
+declare const onLabelDeleted: ReturnType<typeof createEventModule$1<_publicOnLabelDeletedType>>;
+
+type context$2_ContactLabel = ContactLabel;
+type context$2_ContactLabelNamespace = ContactLabelNamespace;
+type context$2_ContactLabelNonNullableFields = ContactLabelNonNullableFields;
+type context$2_DeleteLabelRequest = DeleteLabelRequest;
+type context$2_DeleteLabelResponse = DeleteLabelResponse;
+type context$2_FindOrCreateLabelOptions = FindOrCreateLabelOptions;
+type context$2_FindOrCreateLabelRequest = FindOrCreateLabelRequest;
+type context$2_FindOrCreateLabelResponse = FindOrCreateLabelResponse;
+type context$2_FindOrCreateLabelResponseNonNullableFields = FindOrCreateLabelResponseNonNullableFields;
+type context$2_GdprListRequest = GdprListRequest;
+type context$2_GdprListResponse = GdprListResponse;
+type context$2_GetLabelByLegacyIdRequest = GetLabelByLegacyIdRequest;
+type context$2_GetLabelByLegacyIdResponse = GetLabelByLegacyIdResponse;
+type context$2_GetLabelOptions = GetLabelOptions;
+type context$2_GetLabelRequest = GetLabelRequest;
+type context$2_GetLabelResponse = GetLabelResponse;
+type context$2_GetLabelResponseNonNullableFields = GetLabelResponseNonNullableFields;
+type context$2_LabelCreatedEnvelope = LabelCreatedEnvelope;
+type context$2_LabelDeletedEnvelope = LabelDeletedEnvelope;
+type context$2_LabelType = LabelType;
+declare const context$2_LabelType: typeof LabelType;
+type context$2_LabelUpdatedEnvelope = LabelUpdatedEnvelope;
+type context$2_LabelsQueryBuilder = LabelsQueryBuilder;
+type context$2_LabelsQueryResult = LabelsQueryResult;
+type context$2_LabelsQuotaReached = LabelsQuotaReached;
+type context$2_ListLabelNamespacesRequest = ListLabelNamespacesRequest;
+type context$2_ListLabelNamespacesResponse = ListLabelNamespacesResponse;
+type context$2_ListLabelsRequest = ListLabelsRequest;
+type context$2_ListLabelsResponse = ListLabelsResponse;
+type context$2_PagingMetadata = PagingMetadata;
+type context$2_PurgeRequest = PurgeRequest;
+type context$2_PurgeResponse = PurgeResponse;
+type context$2_Query = Query;
+type context$2_QueryLabelsOptions = QueryLabelsOptions;
+type context$2_QueryLabelsRequest = QueryLabelsRequest;
+type context$2_QueryLabelsResponse = QueryLabelsResponse;
+type context$2_QueryLabelsResponseNonNullableFields = QueryLabelsResponseNonNullableFields;
+type context$2_RenameLabel = RenameLabel;
+type context$2_RenameLabelOptions = RenameLabelOptions;
+type context$2_RestoreInfo = RestoreInfo;
+type context$2_UpdateLabelRequest = UpdateLabelRequest;
+type context$2_UpdateLabelResponse = UpdateLabelResponse;
+type context$2_UpdateLabelResponseNonNullableFields = UpdateLabelResponseNonNullableFields;
+type context$2__publicOnLabelCreatedType = _publicOnLabelCreatedType;
+type context$2__publicOnLabelDeletedType = _publicOnLabelDeletedType;
+type context$2__publicOnLabelUpdatedType = _publicOnLabelUpdatedType;
+declare const context$2_deleteLabel: typeof deleteLabel;
+declare const context$2_findOrCreateLabel: typeof findOrCreateLabel;
+declare const context$2_getLabel: typeof getLabel;
+declare const context$2_onLabelCreated: typeof onLabelCreated;
+declare const context$2_onLabelDeleted: typeof onLabelDeleted;
+declare const context$2_onLabelUpdated: typeof onLabelUpdated;
+declare const context$2_queryLabels: typeof queryLabels;
+declare const context$2_renameLabel: typeof renameLabel;
+declare namespace context$2 {
+  export { type ActionEvent$1 as ActionEvent, type BaseEventMetadata$1 as BaseEventMetadata, type context$2_ContactLabel as ContactLabel, type context$2_ContactLabelNamespace as ContactLabelNamespace, type context$2_ContactLabelNonNullableFields as ContactLabelNonNullableFields, type context$2_DeleteLabelRequest as DeleteLabelRequest, type context$2_DeleteLabelResponse as DeleteLabelResponse, type DomainEvent$1 as DomainEvent, type DomainEventBodyOneOf$1 as DomainEventBodyOneOf, type EntityCreatedEvent$1 as EntityCreatedEvent, type EntityDeletedEvent$1 as EntityDeletedEvent, type EntityUpdatedEvent$1 as EntityUpdatedEvent, type EventMetadata$1 as EventMetadata, type context$2_FindOrCreateLabelOptions as FindOrCreateLabelOptions, type context$2_FindOrCreateLabelRequest as FindOrCreateLabelRequest, type context$2_FindOrCreateLabelResponse as FindOrCreateLabelResponse, type context$2_FindOrCreateLabelResponseNonNullableFields as FindOrCreateLabelResponseNonNullableFields, type context$2_GdprListRequest as GdprListRequest, type context$2_GdprListResponse as GdprListResponse, type context$2_GetLabelByLegacyIdRequest as GetLabelByLegacyIdRequest, type context$2_GetLabelByLegacyIdResponse as GetLabelByLegacyIdResponse, type context$2_GetLabelOptions as GetLabelOptions, type context$2_GetLabelRequest as GetLabelRequest, type context$2_GetLabelResponse as GetLabelResponse, type context$2_GetLabelResponseNonNullableFields as GetLabelResponseNonNullableFields, type IdentificationData$2 as IdentificationData, type IdentificationDataIdOneOf$2 as IdentificationDataIdOneOf, type context$2_LabelCreatedEnvelope as LabelCreatedEnvelope, type context$2_LabelDeletedEnvelope as LabelDeletedEnvelope, context$2_LabelType as LabelType, type context$2_LabelUpdatedEnvelope as LabelUpdatedEnvelope, type context$2_LabelsQueryBuilder as LabelsQueryBuilder, type context$2_LabelsQueryResult as LabelsQueryResult, type context$2_LabelsQuotaReached as LabelsQuotaReached, type context$2_ListLabelNamespacesRequest as ListLabelNamespacesRequest, type context$2_ListLabelNamespacesResponse as ListLabelNamespacesResponse, type context$2_ListLabelsRequest as ListLabelsRequest, type context$2_ListLabelsResponse as ListLabelsResponse, type MessageEnvelope$2 as MessageEnvelope, type Paging$1 as Paging, type context$2_PagingMetadata as PagingMetadata, type context$2_PurgeRequest as PurgeRequest, type context$2_PurgeResponse as PurgeResponse, type context$2_Query as Query, type context$2_QueryLabelsOptions as QueryLabelsOptions, type context$2_QueryLabelsRequest as QueryLabelsRequest, type context$2_QueryLabelsResponse as QueryLabelsResponse, type context$2_QueryLabelsResponseNonNullableFields as QueryLabelsResponseNonNullableFields, type context$2_RenameLabel as RenameLabel, type context$2_RenameLabelOptions as RenameLabelOptions, type context$2_RestoreInfo as RestoreInfo, SortOrder$1 as SortOrder, type Sorting$1 as Sorting, type context$2_UpdateLabelRequest as UpdateLabelRequest, type context$2_UpdateLabelResponse as UpdateLabelResponse, type context$2_UpdateLabelResponseNonNullableFields as UpdateLabelResponseNonNullableFields, WebhookIdentityType$2 as WebhookIdentityType, type context$2__publicOnLabelCreatedType as _publicOnLabelCreatedType, type context$2__publicOnLabelDeletedType as _publicOnLabelDeletedType, type context$2__publicOnLabelUpdatedType as _publicOnLabelUpdatedType, context$2_deleteLabel as deleteLabel, context$2_findOrCreateLabel as findOrCreateLabel, context$2_getLabel as getLabel, context$2_onLabelCreated as onLabelCreated, context$2_onLabelDeleted as onLabelDeleted, context$2_onLabelUpdated as onLabelUpdated, onLabelCreated$1 as publicOnLabelCreated, onLabelDeleted$1 as publicOnLabelDeleted, onLabelUpdated$1 as publicOnLabelUpdated, context$2_queryLabels as queryLabels, context$2_renameLabel as renameLabel };
+}
+
+type HostModule$1<T, H extends Host$1> = {
+    __type: 'host';
+    create(host: H): T;
+};
+type HostModuleAPI$1<T extends HostModule$1<any, any>> = T extends HostModule$1<infer U, any> ? U : never;
+type Host$1<Environment = unknown> = {
+    channel: {
+        observeState(callback: (props: unknown, environment: Environment) => unknown): {
+            disconnect: () => void;
+        } | Promise<{
+            disconnect: () => void;
+        }>;
+    };
+    environment?: Environment;
+    /**
+     * Optional name of the environment, use for logging
+     */
+    name?: string;
+    /**
+     * Optional bast url to use for API requests, for example `www.wixapis.com`
+     */
+    apiBaseUrl?: string;
+    /**
+     * Possible data to be provided by every host, for cross cutting concerns
+     * like internationalization, billing, etc.
+     */
+    essentials?: {
+        /**
+         * The language of the currently viewed session
+         */
+        language?: string;
+        /**
+         * The locale of the currently viewed session
+         */
+        locale?: string;
+        /**
+         * Any headers that should be passed through to the API requests
+         */
+        passThroughHeaders?: Record<string, string>;
+    };
+};
+
+type RESTFunctionDescriptor$1<T extends (...args: any[]) => any = (...args: any[]) => any> = (httpClient: HttpClient$1) => T;
+interface HttpClient$1 {
+    request<TResponse, TData = any>(req: RequestOptionsFactory$1<TResponse, TData>): Promise<HttpResponse$1<TResponse>>;
+    fetchWithAuth: typeof fetch;
+    wixAPIFetch: (relativeUrl: string, options: RequestInit) => Promise<Response>;
+    getActiveToken?: () => string | undefined;
+}
+type RequestOptionsFactory$1<TResponse = any, TData = any> = (context: any) => RequestOptions$1<TResponse, TData>;
+type HttpResponse$1<T = any> = {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: any;
+    request?: any;
+};
+type RequestOptions$1<_TResponse = any, Data = any> = {
+    method: 'POST' | 'GET' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+    url: string;
+    data?: Data;
+    params?: URLSearchParams;
+} & APIMetadata$1;
+type APIMetadata$1 = {
+    methodFqn?: string;
+    entityFqdn?: string;
+    packageName?: string;
+};
+type BuildRESTFunction$1<T extends RESTFunctionDescriptor$1> = T extends RESTFunctionDescriptor$1<infer U> ? U : never;
+type EventDefinition$1<Payload = unknown, Type extends string = string> = {
+    __type: 'event-definition';
+    type: Type;
+    isDomainEvent?: boolean;
+    transformations?: (envelope: unknown) => Payload;
+    __payload: Payload;
+};
+declare function EventDefinition$1<Type extends string>(type: Type, isDomainEvent?: boolean, transformations?: (envelope: any) => unknown): <Payload = unknown>() => EventDefinition$1<Payload, Type>;
+type EventHandler$1<T extends EventDefinition$1> = (payload: T['__payload']) => void | Promise<void>;
+type BuildEventDefinition$1<T extends EventDefinition$1<any, string>> = (handler: EventHandler$1<T>) => void;
+
+type ServicePluginMethodInput$1 = {
+    request: any;
+    metadata: any;
+};
+type ServicePluginContract$1 = Record<string, (payload: ServicePluginMethodInput$1) => unknown | Promise<unknown>>;
+type ServicePluginMethodMetadata$1 = {
+    name: string;
+    primaryHttpMappingPath: string;
+    transformations: {
+        fromREST: (...args: unknown[]) => ServicePluginMethodInput$1;
+        toREST: (...args: unknown[]) => unknown;
+    };
+};
+type ServicePluginDefinition$1<Contract extends ServicePluginContract$1> = {
+    __type: 'service-plugin-definition';
+    componentType: string;
+    methods: ServicePluginMethodMetadata$1[];
+    __contract: Contract;
+};
+declare function ServicePluginDefinition$1<Contract extends ServicePluginContract$1>(componentType: string, methods: ServicePluginMethodMetadata$1[]): ServicePluginDefinition$1<Contract>;
+type BuildServicePluginDefinition$1<T extends ServicePluginDefinition$1<any>> = (implementation: T['__contract']) => void;
+declare const SERVICE_PLUGIN_ERROR_TYPE$1 = "wix_spi_error";
+
+type RequestContext$1 = {
+    isSSR: boolean;
+    host: string;
+    protocol?: string;
+};
+type ResponseTransformer$1 = (data: any, headers?: any) => any;
+/**
+ * Ambassador request options types are copied mostly from AxiosRequestConfig.
+ * They are copied and not imported to reduce the amount of dependencies (to reduce install time).
+ * https://github.com/axios/axios/blob/3f53eb6960f05a1f88409c4b731a40de595cb825/index.d.ts#L307-L315
+ */
+type Method$1 = 'get' | 'GET' | 'delete' | 'DELETE' | 'head' | 'HEAD' | 'options' | 'OPTIONS' | 'post' | 'POST' | 'put' | 'PUT' | 'patch' | 'PATCH' | 'purge' | 'PURGE' | 'link' | 'LINK' | 'unlink' | 'UNLINK';
+type AmbassadorRequestOptions$1<T = any> = {
+    _?: T;
+    url?: string;
+    method?: Method$1;
+    params?: any;
+    data?: any;
+    transformResponse?: ResponseTransformer$1 | ResponseTransformer$1[];
+};
+type AmbassadorFactory$1<Request, Response> = (payload: Request) => ((context: RequestContext$1) => AmbassadorRequestOptions$1<Response>) & {
+    __isAmbassador: boolean;
+};
+type AmbassadorFunctionDescriptor$1<Request = any, Response = any> = AmbassadorFactory$1<Request, Response>;
+type BuildAmbassadorFunction$1<T extends AmbassadorFunctionDescriptor$1> = T extends AmbassadorFunctionDescriptor$1<infer Request, infer Response> ? (req: Request) => Promise<Response> : never;
+
+declare global {
+	// eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
+	interface SymbolConstructor {
+		readonly observable: symbol;
+	}
+}
+
+declare const emptyObjectSymbol$1: unique symbol;
+
+/**
+Represents a strictly empty plain object, the `{}` value.
+
+When you annotate something as the type `{}`, it can be anything except `null` and `undefined`. This means that you cannot use `{}` to represent an empty plain object ([read more](https://stackoverflow.com/questions/47339869/typescript-empty-object-and-any-difference/52193484#52193484)).
+
+@example
+```
+import type {EmptyObject} from 'type-fest';
+
+// The following illustrates the problem with `{}`.
+const foo1: {} = {}; // Pass
+const foo2: {} = []; // Pass
+const foo3: {} = 42; // Pass
+const foo4: {} = {a: 1}; // Pass
+
+// With `EmptyObject` only the first case is valid.
+const bar1: EmptyObject = {}; // Pass
+const bar2: EmptyObject = 42; // Fail
+const bar3: EmptyObject = []; // Fail
+const bar4: EmptyObject = {a: 1}; // Fail
+```
+
+Unfortunately, `Record<string, never>`, `Record<keyof any, never>` and `Record<never, never>` do not work. See {@link https://github.com/sindresorhus/type-fest/issues/395 #395}.
+
+@category Object
+*/
+type EmptyObject$1 = {[emptyObjectSymbol$1]?: never};
+
+/**
+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$1<A, B> =
+	(<G>() => G extends A ? 1 : 2) extends
+	(<G>() => G extends B ? 1 : 2)
+		? true
+		: false;
+
+/**
+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$1<KeyType, ExcludeType> = IsEqual$1<KeyType, ExcludeType> extends true ? never : (KeyType extends ExcludeType ? never : KeyType);
+
+type ExceptOptions$1 = {
+	/**
+	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;
+};
+
+/**
+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}
+
+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>>
+
+const fooWithoutB: FooWithoutB = {a: 1, b: '2'};
+//=> errors at 'b': Type 'string' is not assignable to type 'undefined'.
+```
+
+@category Object
+*/
+type Except$1<ObjectType, KeysType extends keyof ObjectType, Options extends ExceptOptions$1 = {requireExactProps: false}> = {
+	[KeyType in keyof ObjectType as Filter$1<KeyType, KeysType>]: ObjectType[KeyType];
+} & (Options['requireExactProps'] extends true
+	? Partial<Record<KeysType, never>>
+	: {});
+
+/**
+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';
+
+// https://github.com/andnp/SimplyTyped/blob/master/src/types/strings.ts
+type AreStringsEqual<A extends string, B extends string> =
+	And<
+		IsNever<Exclude<A, B>> extends true ? true : false,
+		IsNever<Exclude<B, A>> extends true ? true : false
+	>;
+
+type EndIfEqual<I extends string, O extends string> =
+	AreStringsEqual<I, O> extends true
+		? never
+		: void;
+
+function endIfEqual<I extends string, O extends string>(input: I, output: O): EndIfEqual<I, O> {
+	if (input === output) {
+		process.exit(0);
+	}
+}
+
+endIfEqual('abc', 'abc');
+//=> never
+
+endIfEqual('abc', '123');
+//=> void
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsNever$1<T> = [T] extends [never] ? true : false;
+
+/**
+An if-else-like type that resolves depending on whether the given type is `never`.
+
+@see {@link IsNever}
+
+@example
+```
+import type {IfNever} from 'type-fest';
+
+type ShouldBeTrue = IfNever<never>;
+//=> true
+
+type ShouldBeBar = IfNever<'not never', 'foo', 'bar'>;
+//=> 'bar'
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IfNever$1<T, TypeIfNever = true, TypeIfNotNever = false> = (
+	IsNever$1<T> extends true ? TypeIfNever : TypeIfNotNever
+);
+
+/**
+Extract the keys from a type where the value type of the key extends the given `Condition`.
+
+Internally this is used for the `ConditionalPick` and `ConditionalExcept` types.
+
+@example
+```
+import type {ConditionalKeys} from 'type-fest';
+
+interface Example {
+	a: string;
+	b: string | number;
+	c?: string;
+	d: {};
+}
 
-declare function createEventModule$1<T extends EventDefinition<any, string>>(eventDefinition: T): BuildEventDefinition<T> & T;
+type StringKeysOnly = ConditionalKeys<Example, string>;
+//=> 'a'
+```
 
-declare const findOrCreateLabel: BuildRESTFunction<typeof findOrCreateLabel$1> & typeof findOrCreateLabel$1;
-declare const getLabel: BuildRESTFunction<typeof getLabel$1> & typeof getLabel$1;
-declare const renameLabel: BuildRESTFunction<typeof renameLabel$1> & typeof renameLabel$1;
-declare const deleteLabel: BuildRESTFunction<typeof deleteLabel$1> & typeof deleteLabel$1;
-declare const queryLabels: BuildRESTFunction<typeof queryLabels$1> & typeof queryLabels$1;
+To support partial types, make sure your `Condition` is a union of undefined (for example, `string | undefined`) as demonstrated below.
+
+@example
+```
+import type {ConditionalKeys} from 'type-fest';
+
+type StringKeysAndUndefined = ConditionalKeys<Example, string | undefined>;
+//=> 'a' | 'c'
+```
+
+@category Object
+*/
+type ConditionalKeys$1<Base, Condition> =
+{
+	// Map through all the keys of the given base type.
+	[Key in keyof Base]-?:
+	// Pick only keys with types extending the given `Condition` type.
+	Base[Key] extends Condition
+	// Retain this key
+	// If the value for the key extends never, only include it if `Condition` also extends never
+		? IfNever$1<Base[Key], IfNever$1<Condition, Key, never>, Key>
+	// Discard this key since the condition fails.
+		: never;
+	// Convert the produced object into a union type of the keys which passed the conditional test.
+}[keyof Base];
 
-type _publicOnLabelCreatedType = typeof onLabelCreated$1;
 /**
- * Triggered when a label is created.
- */
-declare const onLabelCreated: ReturnType<typeof createEventModule$1<_publicOnLabelCreatedType>>;
+Exclude keys from a shape that matches the given `Condition`.
+
+This is useful when you want to create a new type with a specific set of keys from a shape. For example, you might want to exclude all the primitive properties from a class and form a new shape containing everything but the primitive properties.
+
+@example
+```
+import type {Primitive, ConditionalExcept} from 'type-fest';
+
+class Awesome {
+	name: string;
+	successes: number;
+	failures: bigint;
+
+	run() {}
+}
+
+type ExceptPrimitivesFromAwesome = ConditionalExcept<Awesome, Primitive>;
+//=> {run: () => void}
+```
+
+@example
+```
+import type {ConditionalExcept} from 'type-fest';
+
+interface Example {
+	a: string;
+	b: string | number;
+	c: () => void;
+	d: {};
+}
+
+type NonStringKeysOnly = ConditionalExcept<Example, string>;
+//=> {b: string | number; c: () => void; d: {}}
+```
+
+@category Object
+*/
+type ConditionalExcept$1<Base, Condition> = Except$1<
+Base,
+ConditionalKeys$1<Base, Condition>
+>;
 
-type _publicOnLabelUpdatedType = typeof onLabelUpdated$1;
 /**
- * Triggered when a label is updated.
+ * Descriptors are objects that describe the API of a module, and the module
+ * can either be a REST module or a host module.
+ * This type is recursive, so it can describe nested modules.
  */
-declare const onLabelUpdated: ReturnType<typeof createEventModule$1<_publicOnLabelUpdatedType>>;
-
-type _publicOnLabelDeletedType = typeof onLabelDeleted$1;
+type Descriptors$1 = RESTFunctionDescriptor$1 | AmbassadorFunctionDescriptor$1 | HostModule$1<any, any> | EventDefinition$1<any> | ServicePluginDefinition$1<any> | {
+    [key: string]: Descriptors$1 | PublicMetadata$1 | any;
+};
 /**
- * Triggered when a label is deleted.
+ * This type takes in a descriptors object of a certain Host (including an `unknown` host)
+ * and returns an object with the same structure, but with all descriptors replaced with their API.
+ * Any non-descriptor properties are removed from the returned object, including descriptors that
+ * do not match the given host (as they will not work with the given host).
  */
-declare const onLabelDeleted: ReturnType<typeof createEventModule$1<_publicOnLabelDeletedType>>;
+type BuildDescriptors$1<T extends Descriptors$1, H extends Host$1<any> | undefined, Depth extends number = 5> = {
+    done: T;
+    recurse: T extends {
+        __type: typeof SERVICE_PLUGIN_ERROR_TYPE$1;
+    } ? never : T extends AmbassadorFunctionDescriptor$1 ? BuildAmbassadorFunction$1<T> : T extends RESTFunctionDescriptor$1 ? BuildRESTFunction$1<T> : T extends EventDefinition$1<any> ? BuildEventDefinition$1<T> : T extends ServicePluginDefinition$1<any> ? BuildServicePluginDefinition$1<T> : T extends HostModule$1<any, any> ? HostModuleAPI$1<T> : ConditionalExcept$1<{
+        [Key in keyof T]: T[Key] extends Descriptors$1 ? BuildDescriptors$1<T[Key], H, [
+            -1,
+            0,
+            1,
+            2,
+            3,
+            4,
+            5
+        ][Depth]> : never;
+    }, EmptyObject$1>;
+}[Depth extends -1 ? 'done' : 'recurse'];
+type PublicMetadata$1 = {
+    PACKAGE_NAME?: string;
+};
 
-type context$2_ContactLabel = ContactLabel;
-type context$2_ContactLabelNamespace = ContactLabelNamespace;
-type context$2_ContactLabelNonNullableFields = ContactLabelNonNullableFields;
-type context$2_DeleteLabelRequest = DeleteLabelRequest;
-type context$2_DeleteLabelResponse = DeleteLabelResponse;
-type context$2_FindOrCreateLabelOptions = FindOrCreateLabelOptions;
-type context$2_FindOrCreateLabelRequest = FindOrCreateLabelRequest;
-type context$2_FindOrCreateLabelResponse = FindOrCreateLabelResponse;
-type context$2_FindOrCreateLabelResponseNonNullableFields = FindOrCreateLabelResponseNonNullableFields;
-type context$2_GdprListRequest = GdprListRequest;
-type context$2_GdprListResponse = GdprListResponse;
-type context$2_GetLabelByLegacyIdRequest = GetLabelByLegacyIdRequest;
-type context$2_GetLabelByLegacyIdResponse = GetLabelByLegacyIdResponse;
-type context$2_GetLabelOptions = GetLabelOptions;
-type context$2_GetLabelRequest = GetLabelRequest;
-type context$2_GetLabelResponse = GetLabelResponse;
-type context$2_GetLabelResponseNonNullableFields = GetLabelResponseNonNullableFields;
-type context$2_LabelCreatedEnvelope = LabelCreatedEnvelope;
-type context$2_LabelDeletedEnvelope = LabelDeletedEnvelope;
-type context$2_LabelType = LabelType;
-declare const context$2_LabelType: typeof LabelType;
-type context$2_LabelUpdatedEnvelope = LabelUpdatedEnvelope;
-type context$2_LabelsQueryBuilder = LabelsQueryBuilder;
-type context$2_LabelsQueryResult = LabelsQueryResult;
-type context$2_LabelsQuotaReached = LabelsQuotaReached;
-type context$2_ListLabelNamespacesRequest = ListLabelNamespacesRequest;
-type context$2_ListLabelNamespacesResponse = ListLabelNamespacesResponse;
-type context$2_ListLabelsRequest = ListLabelsRequest;
-type context$2_ListLabelsResponse = ListLabelsResponse;
-type context$2_PagingMetadata = PagingMetadata;
-type context$2_PurgeRequest = PurgeRequest;
-type context$2_PurgeResponse = PurgeResponse;
-type context$2_Query = Query;
-type context$2_QueryLabelsOptions = QueryLabelsOptions;
-type context$2_QueryLabelsRequest = QueryLabelsRequest;
-type context$2_QueryLabelsResponse = QueryLabelsResponse;
-type context$2_QueryLabelsResponseNonNullableFields = QueryLabelsResponseNonNullableFields;
-type context$2_RenameLabel = RenameLabel;
-type context$2_RenameLabelOptions = RenameLabelOptions;
-type context$2_RestoreInfo = RestoreInfo;
-type context$2_UpdateLabelRequest = UpdateLabelRequest;
-type context$2_UpdateLabelResponse = UpdateLabelResponse;
-type context$2_UpdateLabelResponseNonNullableFields = UpdateLabelResponseNonNullableFields;
-type context$2__publicOnLabelCreatedType = _publicOnLabelCreatedType;
-type context$2__publicOnLabelDeletedType = _publicOnLabelDeletedType;
-type context$2__publicOnLabelUpdatedType = _publicOnLabelUpdatedType;
-declare const context$2_deleteLabel: typeof deleteLabel;
-declare const context$2_findOrCreateLabel: typeof findOrCreateLabel;
-declare const context$2_getLabel: typeof getLabel;
-declare const context$2_onLabelCreated: typeof onLabelCreated;
-declare const context$2_onLabelDeleted: typeof onLabelDeleted;
-declare const context$2_onLabelUpdated: typeof onLabelUpdated;
-declare const context$2_queryLabels: typeof queryLabels;
-declare const context$2_renameLabel: typeof renameLabel;
-declare namespace context$2 {
-  export { type ActionEvent$1 as ActionEvent, type BaseEventMetadata$1 as BaseEventMetadata, type context$2_ContactLabel as ContactLabel, type context$2_ContactLabelNamespace as ContactLabelNamespace, type context$2_ContactLabelNonNullableFields as ContactLabelNonNullableFields, type context$2_DeleteLabelRequest as DeleteLabelRequest, type context$2_DeleteLabelResponse as DeleteLabelResponse, type DomainEvent$1 as DomainEvent, type DomainEventBodyOneOf$1 as DomainEventBodyOneOf, type EntityCreatedEvent$1 as EntityCreatedEvent, type EntityDeletedEvent$1 as EntityDeletedEvent, type EntityUpdatedEvent$1 as EntityUpdatedEvent, type EventMetadata$1 as EventMetadata, type context$2_FindOrCreateLabelOptions as FindOrCreateLabelOptions, type context$2_FindOrCreateLabelRequest as FindOrCreateLabelRequest, type context$2_FindOrCreateLabelResponse as FindOrCreateLabelResponse, type context$2_FindOrCreateLabelResponseNonNullableFields as FindOrCreateLabelResponseNonNullableFields, type context$2_GdprListRequest as GdprListRequest, type context$2_GdprListResponse as GdprListResponse, type context$2_GetLabelByLegacyIdRequest as GetLabelByLegacyIdRequest, type context$2_GetLabelByLegacyIdResponse as GetLabelByLegacyIdResponse, type context$2_GetLabelOptions as GetLabelOptions, type context$2_GetLabelRequest as GetLabelRequest, type context$2_GetLabelResponse as GetLabelResponse, type context$2_GetLabelResponseNonNullableFields as GetLabelResponseNonNullableFields, type IdentificationData$2 as IdentificationData, type IdentificationDataIdOneOf$2 as IdentificationDataIdOneOf, type context$2_LabelCreatedEnvelope as LabelCreatedEnvelope, type context$2_LabelDeletedEnvelope as LabelDeletedEnvelope, context$2_LabelType as LabelType, type context$2_LabelUpdatedEnvelope as LabelUpdatedEnvelope, type context$2_LabelsQueryBuilder as LabelsQueryBuilder, type context$2_LabelsQueryResult as LabelsQueryResult, type context$2_LabelsQuotaReached as LabelsQuotaReached, type context$2_ListLabelNamespacesRequest as ListLabelNamespacesRequest, type context$2_ListLabelNamespacesResponse as ListLabelNamespacesResponse, type context$2_ListLabelsRequest as ListLabelsRequest, type context$2_ListLabelsResponse as ListLabelsResponse, type MessageEnvelope$2 as MessageEnvelope, type Paging$1 as Paging, type context$2_PagingMetadata as PagingMetadata, type context$2_PurgeRequest as PurgeRequest, type context$2_PurgeResponse as PurgeResponse, type context$2_Query as Query, type context$2_QueryLabelsOptions as QueryLabelsOptions, type context$2_QueryLabelsRequest as QueryLabelsRequest, type context$2_QueryLabelsResponse as QueryLabelsResponse, type context$2_QueryLabelsResponseNonNullableFields as QueryLabelsResponseNonNullableFields, type context$2_RenameLabel as RenameLabel, type context$2_RenameLabelOptions as RenameLabelOptions, type context$2_RestoreInfo as RestoreInfo, SortOrder$1 as SortOrder, type Sorting$1 as Sorting, type context$2_UpdateLabelRequest as UpdateLabelRequest, type context$2_UpdateLabelResponse as UpdateLabelResponse, type context$2_UpdateLabelResponseNonNullableFields as UpdateLabelResponseNonNullableFields, WebhookIdentityType$2 as WebhookIdentityType, type context$2__publicOnLabelCreatedType as _publicOnLabelCreatedType, type context$2__publicOnLabelDeletedType as _publicOnLabelDeletedType, type context$2__publicOnLabelUpdatedType as _publicOnLabelUpdatedType, context$2_deleteLabel as deleteLabel, context$2_findOrCreateLabel as findOrCreateLabel, context$2_getLabel as getLabel, context$2_onLabelCreated as onLabelCreated, context$2_onLabelDeleted as onLabelDeleted, context$2_onLabelUpdated as onLabelUpdated, onLabelCreated$1 as publicOnLabelCreated, onLabelDeleted$1 as publicOnLabelDeleted, onLabelUpdated$1 as publicOnLabelUpdated, context$2_queryLabels as queryLabels, context$2_renameLabel as renameLabel };
+declare global {
+    interface ContextualClient {
+    }
 }
+/**
+ * A type used to create concerete types from SDK descriptors in
+ * case a contextual client is available.
+ */
+type MaybeContext$1<T extends Descriptors$1> = globalThis.ContextualClient extends {
+    host: Host$1;
+} ? BuildDescriptors$1<T, globalThis.ContextualClient['host']> : T;
 
 /** Dummy message for fqdn validation */
 interface SubmitContact {
@@ -4913,7 +7259,7 @@ interface AppendOrCreateContactOptions {
     contactId?: string | null;
 }
 
-declare function appendOrCreateContact$1(httpClient: HttpClient): AppendOrCreateContactSignature;
+declare function appendOrCreateContact$1(httpClient: HttpClient$1): AppendOrCreateContactSignature;
 interface AppendOrCreateContactSignature {
     /**
      * Appends an existing contact or creates a contact if it doesn't exist.
@@ -4924,7 +7270,7 @@ interface AppendOrCreateContactSignature {
     (options?: AppendOrCreateContactOptions | undefined): Promise<SubmitContactResponse & SubmitContactResponseNonNullableFields>;
 }
 
-declare const appendOrCreateContact: BuildRESTFunction<typeof appendOrCreateContact$1> & typeof appendOrCreateContact$1;
+declare const appendOrCreateContact: MaybeContext$1<BuildRESTFunction$1<typeof appendOrCreateContact$1> & typeof appendOrCreateContact$1>;
 
 type context$1_ActivityIcon = ActivityIcon;
 type context$1_Address = Address;
@@ -4977,6 +7323,484 @@ declare namespace context$1 {
   export { type context$1_ActivityIcon as ActivityIcon, type context$1_Address as Address, type context$1_AddressLocation as AddressLocation, type context$1_AddressStreetOneOf as AddressStreetOneOf, context$1_AddressTag as AddressTag, type context$1_AppendOrCreateContactOptions as AppendOrCreateContactOptions, type context$1_AssigneesWrapper as AssigneesWrapper, type context$1_ContactActivity as ContactActivity, context$1_ContactActivityType as ContactActivityType, type context$1_ContactAddress as ContactAddress, type context$1_ContactAddressesWrapper as ContactAddressesWrapper, type context$1_ContactEmail as ContactEmail, type context$1_ContactEmailsWrapper as ContactEmailsWrapper, type ContactInfo$1 as ContactInfo, type context$1_ContactName as ContactName, type context$1_ContactPhone as ContactPhone, type context$1_ContactPhonesWrapper as ContactPhonesWrapper, type context$1_ContactPicture as ContactPicture, context$1_ContactSourceType as ContactSourceType, type context$1_ContactToSubmit as ContactToSubmit, context$1_EmailTag as EmailTag, type context$1_ExtendedFieldsWrapper as ExtendedFieldsWrapper, type IdentificationData$1 as IdentificationData, type IdentificationDataIdOneOf$1 as IdentificationDataIdOneOf, context$1_IdentityType as IdentityType, context$1_ImageProvider as ImageProvider, type context$1_LabelsWrapper as LabelsWrapper, type context$1_LocationsWrapper as LocationsWrapper, type MessageEnvelope$1 as MessageEnvelope, context$1_PhoneTag as PhoneTag, type context$1_StreetAddress as StreetAddress, type context$1_Subdivision as Subdivision, context$1_SubdivisionType as SubdivisionType, type context$1_SubmitContact as SubmitContact, type context$1_SubmitContactOptions as SubmitContactOptions, type context$1_SubmitContactRequest as SubmitContactRequest, type context$1_SubmitContactResponse as SubmitContactResponse, type context$1_SubmitContactResponseNonNullableFields as SubmitContactResponseNonNullableFields, context$1_SubmitOperation as SubmitOperation, type context$1_SubmitVisitorIdRequest as SubmitVisitorIdRequest, type context$1_SubmitVisitorIdResponse as SubmitVisitorIdResponse, WebhookIdentityType$1 as WebhookIdentityType, context$1_appendOrCreateContact as appendOrCreateContact };
 }
 
+type HostModule<T, H extends Host> = {
+    __type: 'host';
+    create(host: H): T;
+};
+type HostModuleAPI<T extends HostModule<any, any>> = T extends HostModule<infer U, any> ? U : never;
+type Host<Environment = unknown> = {
+    channel: {
+        observeState(callback: (props: unknown, environment: Environment) => unknown): {
+            disconnect: () => void;
+        } | Promise<{
+            disconnect: () => void;
+        }>;
+    };
+    environment?: Environment;
+    /**
+     * Optional name of the environment, use for logging
+     */
+    name?: string;
+    /**
+     * Optional bast url to use for API requests, for example `www.wixapis.com`
+     */
+    apiBaseUrl?: string;
+    /**
+     * Possible data to be provided by every host, for cross cutting concerns
+     * like internationalization, billing, etc.
+     */
+    essentials?: {
+        /**
+         * The language of the currently viewed session
+         */
+        language?: string;
+        /**
+         * The locale of the currently viewed session
+         */
+        locale?: string;
+        /**
+         * Any headers that should be passed through to the API requests
+         */
+        passThroughHeaders?: Record<string, string>;
+    };
+};
+
+type RESTFunctionDescriptor<T extends (...args: any[]) => any = (...args: any[]) => any> = (httpClient: HttpClient) => T;
+interface HttpClient {
+    request<TResponse, TData = any>(req: RequestOptionsFactory<TResponse, TData>): Promise<HttpResponse<TResponse>>;
+    fetchWithAuth: typeof fetch;
+    wixAPIFetch: (relativeUrl: string, options: RequestInit) => Promise<Response>;
+    getActiveToken?: () => string | undefined;
+}
+type RequestOptionsFactory<TResponse = any, TData = any> = (context: any) => RequestOptions<TResponse, TData>;
+type HttpResponse<T = any> = {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: any;
+    request?: any;
+};
+type RequestOptions<_TResponse = any, Data = any> = {
+    method: 'POST' | 'GET' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+    url: string;
+    data?: Data;
+    params?: URLSearchParams;
+} & APIMetadata;
+type APIMetadata = {
+    methodFqn?: string;
+    entityFqdn?: string;
+    packageName?: string;
+};
+type BuildRESTFunction<T extends RESTFunctionDescriptor> = T extends RESTFunctionDescriptor<infer U> ? U : never;
+type EventDefinition<Payload = unknown, Type extends string = string> = {
+    __type: 'event-definition';
+    type: Type;
+    isDomainEvent?: boolean;
+    transformations?: (envelope: unknown) => Payload;
+    __payload: Payload;
+};
+declare function EventDefinition<Type extends string>(type: Type, isDomainEvent?: boolean, transformations?: (envelope: any) => unknown): <Payload = unknown>() => EventDefinition<Payload, Type>;
+type EventHandler<T extends EventDefinition> = (payload: T['__payload']) => void | Promise<void>;
+type BuildEventDefinition<T extends EventDefinition<any, string>> = (handler: EventHandler<T>) => void;
+
+type ServicePluginMethodInput = {
+    request: any;
+    metadata: any;
+};
+type ServicePluginContract = Record<string, (payload: ServicePluginMethodInput) => unknown | Promise<unknown>>;
+type ServicePluginMethodMetadata = {
+    name: string;
+    primaryHttpMappingPath: string;
+    transformations: {
+        fromREST: (...args: unknown[]) => ServicePluginMethodInput;
+        toREST: (...args: unknown[]) => unknown;
+    };
+};
+type ServicePluginDefinition<Contract extends ServicePluginContract> = {
+    __type: 'service-plugin-definition';
+    componentType: string;
+    methods: ServicePluginMethodMetadata[];
+    __contract: Contract;
+};
+declare function ServicePluginDefinition<Contract extends ServicePluginContract>(componentType: string, methods: ServicePluginMethodMetadata[]): ServicePluginDefinition<Contract>;
+type BuildServicePluginDefinition<T extends ServicePluginDefinition<any>> = (implementation: T['__contract']) => void;
+declare const SERVICE_PLUGIN_ERROR_TYPE = "wix_spi_error";
+
+type RequestContext = {
+    isSSR: boolean;
+    host: string;
+    protocol?: string;
+};
+type ResponseTransformer = (data: any, headers?: any) => any;
+/**
+ * Ambassador request options types are copied mostly from AxiosRequestConfig.
+ * They are copied and not imported to reduce the amount of dependencies (to reduce install time).
+ * https://github.com/axios/axios/blob/3f53eb6960f05a1f88409c4b731a40de595cb825/index.d.ts#L307-L315
+ */
+type Method = 'get' | 'GET' | 'delete' | 'DELETE' | 'head' | 'HEAD' | 'options' | 'OPTIONS' | 'post' | 'POST' | 'put' | 'PUT' | 'patch' | 'PATCH' | 'purge' | 'PURGE' | 'link' | 'LINK' | 'unlink' | 'UNLINK';
+type AmbassadorRequestOptions<T = any> = {
+    _?: T;
+    url?: string;
+    method?: Method;
+    params?: any;
+    data?: any;
+    transformResponse?: ResponseTransformer | ResponseTransformer[];
+};
+type AmbassadorFactory<Request, Response> = (payload: Request) => ((context: RequestContext) => AmbassadorRequestOptions<Response>) & {
+    __isAmbassador: boolean;
+};
+type AmbassadorFunctionDescriptor<Request = any, Response = any> = AmbassadorFactory<Request, Response>;
+type BuildAmbassadorFunction<T extends AmbassadorFunctionDescriptor> = T extends AmbassadorFunctionDescriptor<infer Request, infer Response> ? (req: Request) => Promise<Response> : never;
+
+declare global {
+	// eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
+	interface SymbolConstructor {
+		readonly observable: symbol;
+	}
+}
+
+declare const emptyObjectSymbol: unique symbol;
+
+/**
+Represents a strictly empty plain object, the `{}` value.
+
+When you annotate something as the type `{}`, it can be anything except `null` and `undefined`. This means that you cannot use `{}` to represent an empty plain object ([read more](https://stackoverflow.com/questions/47339869/typescript-empty-object-and-any-difference/52193484#52193484)).
+
+@example
+```
+import type {EmptyObject} from 'type-fest';
+
+// The following illustrates the problem with `{}`.
+const foo1: {} = {}; // Pass
+const foo2: {} = []; // Pass
+const foo3: {} = 42; // Pass
+const foo4: {} = {a: 1}; // Pass
+
+// With `EmptyObject` only the first case is valid.
+const bar1: EmptyObject = {}; // Pass
+const bar2: EmptyObject = 42; // Fail
+const bar3: EmptyObject = []; // Fail
+const bar4: EmptyObject = {a: 1}; // Fail
+```
+
+Unfortunately, `Record<string, never>`, `Record<keyof any, never>` and `Record<never, never>` do not work. See {@link https://github.com/sindresorhus/type-fest/issues/395 #395}.
+
+@category Object
+*/
+type EmptyObject = {[emptyObjectSymbol]?: never};
+
+/**
+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> =
+	(<G>() => G extends A ? 1 : 2) extends
+	(<G>() => G extends B ? 1 : 2)
+		? true
+		: false;
+
+/**
+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;
+};
+
+/**
+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}
+
+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>>
+
+const fooWithoutB: FooWithoutB = {a: 1, b: '2'};
+//=> errors at 'b': Type 'string' is not assignable to type 'undefined'.
+```
+
+@category Object
+*/
+type Except<ObjectType, KeysType extends keyof ObjectType, Options extends ExceptOptions = {requireExactProps: false}> = {
+	[KeyType in keyof ObjectType as Filter<KeyType, KeysType>]: ObjectType[KeyType];
+} & (Options['requireExactProps'] extends true
+	? Partial<Record<KeysType, never>>
+	: {});
+
+/**
+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';
+
+// https://github.com/andnp/SimplyTyped/blob/master/src/types/strings.ts
+type AreStringsEqual<A extends string, B extends string> =
+	And<
+		IsNever<Exclude<A, B>> extends true ? true : false,
+		IsNever<Exclude<B, A>> extends true ? true : false
+	>;
+
+type EndIfEqual<I extends string, O extends string> =
+	AreStringsEqual<I, O> extends true
+		? never
+		: void;
+
+function endIfEqual<I extends string, O extends string>(input: I, output: O): EndIfEqual<I, O> {
+	if (input === output) {
+		process.exit(0);
+	}
+}
+
+endIfEqual('abc', 'abc');
+//=> never
+
+endIfEqual('abc', '123');
+//=> void
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsNever<T> = [T] extends [never] ? true : false;
+
+/**
+An if-else-like type that resolves depending on whether the given type is `never`.
+
+@see {@link IsNever}
+
+@example
+```
+import type {IfNever} from 'type-fest';
+
+type ShouldBeTrue = IfNever<never>;
+//=> true
+
+type ShouldBeBar = IfNever<'not never', 'foo', 'bar'>;
+//=> 'bar'
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IfNever<T, TypeIfNever = true, TypeIfNotNever = false> = (
+	IsNever<T> extends true ? TypeIfNever : TypeIfNotNever
+);
+
+/**
+Extract the keys from a type where the value type of the key extends the given `Condition`.
+
+Internally this is used for the `ConditionalPick` and `ConditionalExcept` types.
+
+@example
+```
+import type {ConditionalKeys} from 'type-fest';
+
+interface Example {
+	a: string;
+	b: string | number;
+	c?: string;
+	d: {};
+}
+
+type StringKeysOnly = ConditionalKeys<Example, string>;
+//=> 'a'
+```
+
+To support partial types, make sure your `Condition` is a union of undefined (for example, `string | undefined`) as demonstrated below.
+
+@example
+```
+import type {ConditionalKeys} from 'type-fest';
+
+type StringKeysAndUndefined = ConditionalKeys<Example, string | undefined>;
+//=> 'a' | 'c'
+```
+
+@category Object
+*/
+type ConditionalKeys<Base, Condition> =
+{
+	// Map through all the keys of the given base type.
+	[Key in keyof Base]-?:
+	// Pick only keys with types extending the given `Condition` type.
+	Base[Key] extends Condition
+	// Retain this key
+	// If the value for the key extends never, only include it if `Condition` also extends never
+		? IfNever<Base[Key], IfNever<Condition, Key, never>, Key>
+	// Discard this key since the condition fails.
+		: never;
+	// Convert the produced object into a union type of the keys which passed the conditional test.
+}[keyof Base];
+
+/**
+Exclude keys from a shape that matches the given `Condition`.
+
+This is useful when you want to create a new type with a specific set of keys from a shape. For example, you might want to exclude all the primitive properties from a class and form a new shape containing everything but the primitive properties.
+
+@example
+```
+import type {Primitive, ConditionalExcept} from 'type-fest';
+
+class Awesome {
+	name: string;
+	successes: number;
+	failures: bigint;
+
+	run() {}
+}
+
+type ExceptPrimitivesFromAwesome = ConditionalExcept<Awesome, Primitive>;
+//=> {run: () => void}
+```
+
+@example
+```
+import type {ConditionalExcept} from 'type-fest';
+
+interface Example {
+	a: string;
+	b: string | number;
+	c: () => void;
+	d: {};
+}
+
+type NonStringKeysOnly = ConditionalExcept<Example, string>;
+//=> {b: string | number; c: () => void; d: {}}
+```
+
+@category Object
+*/
+type ConditionalExcept<Base, Condition> = Except<
+Base,
+ConditionalKeys<Base, Condition>
+>;
+
+/**
+ * Descriptors are objects that describe the API of a module, and the module
+ * can either be a REST module or a host module.
+ * This type is recursive, so it can describe nested modules.
+ */
+type Descriptors = RESTFunctionDescriptor | AmbassadorFunctionDescriptor | HostModule<any, any> | EventDefinition<any> | ServicePluginDefinition<any> | {
+    [key: string]: Descriptors | PublicMetadata | any;
+};
+/**
+ * This type takes in a descriptors object of a certain Host (including an `unknown` host)
+ * and returns an object with the same structure, but with all descriptors replaced with their API.
+ * Any non-descriptor properties are removed from the returned object, including descriptors that
+ * do not match the given host (as they will not work with the given host).
+ */
+type BuildDescriptors<T extends Descriptors, H extends Host<any> | undefined, Depth extends number = 5> = {
+    done: T;
+    recurse: T extends {
+        __type: typeof SERVICE_PLUGIN_ERROR_TYPE;
+    } ? never : T extends AmbassadorFunctionDescriptor ? BuildAmbassadorFunction<T> : T extends RESTFunctionDescriptor ? BuildRESTFunction<T> : T extends EventDefinition<any> ? BuildEventDefinition<T> : T extends ServicePluginDefinition<any> ? BuildServicePluginDefinition<T> : T extends HostModule<any, any> ? HostModuleAPI<T> : ConditionalExcept<{
+        [Key in keyof T]: T[Key] extends Descriptors ? BuildDescriptors<T[Key], H, [
+            -1,
+            0,
+            1,
+            2,
+            3,
+            4,
+            5
+        ][Depth]> : never;
+    }, EmptyObject>;
+}[Depth extends -1 ? 'done' : 'recurse'];
+type PublicMetadata = {
+    PACKAGE_NAME?: string;
+};
+
+declare global {
+    interface ContextualClient {
+    }
+}
+/**
+ * A type used to create concerete types from SDK descriptors in
+ * case a contextual client is available.
+ */
+type MaybeContext<T extends Descriptors> = globalThis.ContextualClient extends {
+    host: Host;
+} ? BuildDescriptors<T, globalThis.ContextualClient['host']> : T;
+
 interface Task {
     /**
      * Task ID.
@@ -5711,13 +8535,13 @@ declare const onTaskDeleted$1: EventDefinition<TaskDeletedEnvelope, "wix.crm.tas
 
 declare function createEventModule<T extends EventDefinition<any, string>>(eventDefinition: T): BuildEventDefinition<T> & T;
 
-declare const createTask: BuildRESTFunction<typeof createTask$1> & typeof createTask$1;
-declare const getTask: BuildRESTFunction<typeof getTask$1> & typeof getTask$1;
-declare const updateTask: BuildRESTFunction<typeof updateTask$1> & typeof updateTask$1;
-declare const deleteTask: BuildRESTFunction<typeof deleteTask$1> & typeof deleteTask$1;
-declare const queryTasks: BuildRESTFunction<typeof queryTasks$1> & typeof queryTasks$1;
-declare const countTasks: BuildRESTFunction<typeof countTasks$1> & typeof countTasks$1;
-declare const moveTaskAfter: BuildRESTFunction<typeof moveTaskAfter$1> & typeof moveTaskAfter$1;
+declare const createTask: MaybeContext<BuildRESTFunction<typeof createTask$1> & typeof createTask$1>;
+declare const getTask: MaybeContext<BuildRESTFunction<typeof getTask$1> & typeof getTask$1>;
+declare const updateTask: MaybeContext<BuildRESTFunction<typeof updateTask$1> & typeof updateTask$1>;
+declare const deleteTask: MaybeContext<BuildRESTFunction<typeof deleteTask$1> & typeof deleteTask$1>;
+declare const queryTasks: MaybeContext<BuildRESTFunction<typeof queryTasks$1> & typeof queryTasks$1>;
+declare const countTasks: MaybeContext<BuildRESTFunction<typeof countTasks$1> & typeof countTasks$1>;
+declare const moveTaskAfter: MaybeContext<BuildRESTFunction<typeof moveTaskAfter$1> & typeof moveTaskAfter$1>;
 
 type _publicOnTaskOverdueType = typeof onTaskOverdue$1;
 /**