@wix/crm 1.0.132 → 1.0.133

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

@@ -1,8 +1,51 @@
+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$5<TResponse = any, TData = any> = (context: any) => RequestOptions$5<TResponse, TData>;
 type HttpResponse$5<T = any> = {
@@ -24,16 +67,65 @@ type APIMetadata$5 = {
     packageName?: string;
 };
 type BuildRESTFunction$5<T extends RESTFunctionDescriptor$5> = T extends RESTFunctionDescriptor$5<infer U> ? U : never;
-type EventDefinition$4<Payload = unknown, Type extends string = string> = {
+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$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;
+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;
@@ -455,15 +889,15 @@ interface GetAttachmentSignature {
      */
     (identifiers: GetAttachmentIdentifiers): Promise<ContactAttachment & ContactAttachmentNonNullableFields>;
 }
-declare const onAttachmentCreated$1: EventDefinition$4<AttachmentCreatedEnvelope, "wix.contacts.v4.attachment_created">;
-declare const onAttachmentDeleted$1: EventDefinition$4<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$4<any, string>>(eventDefinition: T): BuildEventDefinition$4<T> & T;
+declare function createEventModule$4<T extends EventDefinition$5<any, string>>(eventDefinition: T): BuildEventDefinition$5<T> & T;
 
-declare const generateAttachmentUploadUrl: BuildRESTFunction$5<typeof generateAttachmentUploadUrl$1> & typeof generateAttachmentUploadUrl$1;
-declare const listAttachments: BuildRESTFunction$5<typeof listAttachments$1> & typeof listAttachments$1;
-declare const deleteAttachment: BuildRESTFunction$5<typeof deleteAttachment$1> & typeof deleteAttachment$1;
-declare const getAttachment: BuildRESTFunction$5<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,11 +958,54 @@ declare namespace index_d$5 {
   export { type ActionEvent$4 as ActionEvent, type index_d$5_AttachmentCreatedEnvelope as AttachmentCreatedEnvelope, type index_d$5_AttachmentDeletedEnvelope as AttachmentDeletedEnvelope, type index_d$5_AttachmentMedia as AttachmentMedia, type index_d$5_AttachmentMediaMediaOneOf as AttachmentMediaMediaOneOf, type index_d$5_AttachmentMetadata as AttachmentMetadata, type index_d$5_AttachmentSource as AttachmentSource, index_d$5_AttachmentType as AttachmentType, type BaseEventMetadata$4 as BaseEventMetadata, type index_d$5_ContactAttachment as ContactAttachment, type index_d$5_ContactAttachmentMediaOneOf as ContactAttachmentMediaOneOf, type index_d$5_ContactAttachmentNonNullableFields as ContactAttachmentNonNullableFields, type index_d$5_CreateDemoAttachmentRequest as CreateDemoAttachmentRequest, type index_d$5_CreateDemoAttachmentResponse as CreateDemoAttachmentResponse, type index_d$5_CrmAttachment as CrmAttachment, index_d$5_CrmAttachmentAttachmentType as CrmAttachmentAttachmentType, type index_d$5_CrmAttachmentUploadedEvent as CrmAttachmentUploadedEvent, type index_d$5_DeleteAttachmentIdentifiers as DeleteAttachmentIdentifiers, type index_d$5_DeleteAttachmentRequest as DeleteAttachmentRequest, type index_d$5_DeleteAttachmentResponse as DeleteAttachmentResponse, index_d$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 index_d$5_GenerateAttachmentUploadUrlOptions as GenerateAttachmentUploadUrlOptions, type index_d$5_GenerateAttachmentUploadUrlRequest as GenerateAttachmentUploadUrlRequest, type index_d$5_GenerateAttachmentUploadUrlResponse as GenerateAttachmentUploadUrlResponse, type index_d$5_GenerateAttachmentUploadUrlResponseNonNullableFields as GenerateAttachmentUploadUrlResponseNonNullableFields, type index_d$5_GetAttachmentIdentifiers as GetAttachmentIdentifiers, type index_d$5_GetAttachmentRequest as GetAttachmentRequest, type index_d$5_GetAttachmentResponse as GetAttachmentResponse, type index_d$5_GetAttachmentResponseNonNullableFields as GetAttachmentResponseNonNullableFields, type IdentificationData$5 as IdentificationData, type IdentificationDataIdOneOf$5 as IdentificationDataIdOneOf, type index_d$5_ListAttachmentsOptions as ListAttachmentsOptions, type index_d$5_ListAttachmentsRequest as ListAttachmentsRequest, type index_d$5_ListAttachmentsResponse as ListAttachmentsResponse, type index_d$5_ListAttachmentsResponseNonNullableFields as ListAttachmentsResponseNonNullableFields, type index_d$5_MediaFileUploadedEvent as MediaFileUploadedEvent, type MessageEnvelope$5 as MessageEnvelope, type Paging$4 as Paging, type PagingMetadata$3 as PagingMetadata, WebhookIdentityType$5 as WebhookIdentityType, type index_d$5__publicOnAttachmentCreatedType as _publicOnAttachmentCreatedType, type index_d$5__publicOnAttachmentDeletedType as _publicOnAttachmentDeletedType, index_d$5_deleteAttachment as deleteAttachment, index_d$5_generateAttachmentUploadUrl as generateAttachmentUploadUrl, index_d$5_getAttachment as getAttachment, index_d$5_listAttachments as listAttachments, index_d$5_onAttachmentCreated as onAttachmentCreated, index_d$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> = {
@@ -550,16 +1027,65 @@ type APIMetadata$4 = {
     packageName?: string;
 };
 type BuildRESTFunction$4<T extends RESTFunctionDescriptor$4> = T extends RESTFunctionDescriptor$4<infer U> ? U : never;
-type EventDefinition$3<Payload = unknown, Type extends string = string> = {
+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$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;
+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.
@@ -568,6 +1094,348 @@ declare global {
 	}
 }
 
+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.
@@ -2649,21 +3517,21 @@ interface GetContactSignature {
      */
     (_id: string, options?: GetContactOptions | undefined): Promise<Contact & ContactNonNullableFields>;
 }
-declare const onContactCreated$1: EventDefinition$3<ContactCreatedEnvelope, "wix.contacts.v4.contact_created">;
-declare const onContactUpdated$1: EventDefinition$3<ContactUpdatedEnvelope, "wix.contacts.v4.contact_updated">;
-declare const onContactMerged$1: EventDefinition$3<ContactMergedEnvelope, "wix.contacts.v4.contact_merged">;
-declare const onContactDeleted$1: EventDefinition$3<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$3<any, string>>(eventDefinition: T): BuildEventDefinition$3<T> & T;
+declare function createEventModule$3<T extends EventDefinition$4<any, string>>(eventDefinition: T): BuildEventDefinition$4<T> & T;
 
-declare const createContact: BuildRESTFunction$4<typeof createContact$1> & typeof createContact$1;
-declare const updateContact: BuildRESTFunction$4<typeof updateContact$1> & typeof updateContact$1;
-declare const mergeContacts: BuildRESTFunction$4<typeof mergeContacts$1> & typeof mergeContacts$1;
-declare const deleteContact: BuildRESTFunction$4<typeof deleteContact$1> & typeof deleteContact$1;
-declare const labelContact: BuildRESTFunction$4<typeof labelContact$1> & typeof labelContact$1;
-declare const unlabelContact: BuildRESTFunction$4<typeof unlabelContact$1> & typeof unlabelContact$1;
-declare const queryContacts: BuildRESTFunction$4<typeof queryContacts$1> & typeof queryContacts$1;
-declare const getContact: BuildRESTFunction$4<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;
 /**
@@ -2850,11 +3718,54 @@ declare namespace index_d$4 {
   export { index_d$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 index_d$4_ApplicationError as ApplicationError, type AssigneesWrapper$1 as AssigneesWrapper, type BaseEventMetadata$3 as BaseEventMetadata, type index_d$4_BulkActionMetadata as BulkActionMetadata, type index_d$4_BulkAddSegmentToContactsRequest as BulkAddSegmentToContactsRequest, type index_d$4_BulkAddSegmentToContactsResponse as BulkAddSegmentToContactsResponse, type index_d$4_BulkDeleteContactsRequest as BulkDeleteContactsRequest, type index_d$4_BulkDeleteContactsResponse as BulkDeleteContactsResponse, type index_d$4_BulkLabelAndUnlabelContactsRequest as BulkLabelAndUnlabelContactsRequest, type index_d$4_BulkLabelAndUnlabelContactsResponse as BulkLabelAndUnlabelContactsResponse, type index_d$4_BulkRemoveSegmentFromContactsRequest as BulkRemoveSegmentFromContactsRequest, type index_d$4_BulkRemoveSegmentFromContactsResponse as BulkRemoveSegmentFromContactsResponse, type index_d$4_BulkUpdateContactsRequest as BulkUpdateContactsRequest, type index_d$4_BulkUpdateContactsResponse as BulkUpdateContactsResponse, type index_d$4_BulkUpsertContactsRequest as BulkUpsertContactsRequest, type index_d$4_BulkUpsertContactsResponse as BulkUpsertContactsResponse, type index_d$4_BulkUpsertContactsResponseMetadata as BulkUpsertContactsResponseMetadata, type index_d$4_Contact as Contact, type ContactActivity$1 as ContactActivity, ContactActivityType$1 as ContactActivityType, type index_d$4_ContactAddedToSegment as ContactAddedToSegment, type ContactAddress$1 as ContactAddress, type ContactAddressesWrapper$1 as ContactAddressesWrapper, type index_d$4_ContactChanged as ContactChanged, type index_d$4_ContactCreatedEnvelope as ContactCreatedEnvelope, type index_d$4_ContactDeletedEnvelope as ContactDeletedEnvelope, type ContactEmail$1 as ContactEmail, type index_d$4_ContactEmailSubscriptionUpdated as ContactEmailSubscriptionUpdated, type ContactEmailsWrapper$1 as ContactEmailsWrapper, index_d$4_ContactFieldSet as ContactFieldSet, type ContactInfo$2 as ContactInfo, type index_d$4_ContactMerged as ContactMerged, type index_d$4_ContactMergedEnvelope as ContactMergedEnvelope, type ContactName$1 as ContactName, type index_d$4_ContactNonNullableFields as ContactNonNullableFields, type ContactPhone$1 as ContactPhone, type index_d$4_ContactPhoneSubscriptionUpdated as ContactPhoneSubscriptionUpdated, type ContactPhonesWrapper$1 as ContactPhonesWrapper, type ContactPicture$1 as ContactPicture, type index_d$4_ContactPrimaryInfoUpdated as ContactPrimaryInfoUpdated, type index_d$4_ContactRemovedFromSegment as ContactRemovedFromSegment, type index_d$4_ContactSource as ContactSource, ContactSourceType$1 as ContactSourceType, type index_d$4_ContactSubmitted as ContactSubmitted, type index_d$4_ContactUpdatedEnvelope as ContactUpdatedEnvelope, type index_d$4_ContactsFacet as ContactsFacet, index_d$4_ContactsFacetType as ContactsFacetType, type index_d$4_ContactsQueryBuilder as ContactsQueryBuilder, type index_d$4_ContactsQueryResult as ContactsQueryResult, type index_d$4_CountContactsRequest as CountContactsRequest, type index_d$4_CountContactsResponse as CountContactsResponse, type index_d$4_CreateContactOptions as CreateContactOptions, type index_d$4_CreateContactRequest as CreateContactRequest, type index_d$4_CreateContactResponse as CreateContactResponse, type index_d$4_CreateContactResponseNonNullableFields as CreateContactResponseNonNullableFields, type CursorPaging$1 as CursorPaging, type CursorPagingMetadata$1 as CursorPagingMetadata, type Cursors$1 as Cursors, type index_d$4_DeleteContactRequest as DeleteContactRequest, type index_d$4_DeleteContactResponse as DeleteContactResponse, type DomainEvent$3 as DomainEvent, type DomainEventBodyOneOf$3 as DomainEventBodyOneOf, type index_d$4_DuplicateContactExists as DuplicateContactExists, index_d$4_EmailDeliverabilityStatus as EmailDeliverabilityStatus, EmailTag$1 as EmailTag, type EntityCreatedEvent$3 as EntityCreatedEvent, type EntityDeletedEvent$3 as EntityDeletedEvent, type EntityUpdatedEvent$3 as EntityUpdatedEvent, type index_d$4_Error as Error, type EventMetadata$3 as EventMetadata, type ExtendedFieldsWrapper$1 as ExtendedFieldsWrapper, type index_d$4_GeneratePictureUploadUrlRequest as GeneratePictureUploadUrlRequest, type index_d$4_GeneratePictureUploadUrlResponse as GeneratePictureUploadUrlResponse, type index_d$4_GetContactOptions as GetContactOptions, type index_d$4_GetContactRequest as GetContactRequest, type index_d$4_GetContactResponse as GetContactResponse, type index_d$4_GetContactResponseNonNullableFields as GetContactResponseNonNullableFields, index_d$4_GetContactResponseType as GetContactResponseType, type index_d$4_GroupInfo as GroupInfo, type IdentificationData$4 as IdentificationData, type IdentificationDataIdOneOf$4 as IdentificationDataIdOneOf, ImageProvider$1 as ImageProvider, type index_d$4_Item as Item, type index_d$4_ItemMetadata as ItemMetadata, type index_d$4_LabelAndUnlabelContactRequest as LabelAndUnlabelContactRequest, type index_d$4_LabelAndUnlabelContactResponse as LabelAndUnlabelContactResponse, type index_d$4_LabelContactRequest as LabelContactRequest, type index_d$4_LabelContactResponse as LabelContactResponse, type index_d$4_LabelContactResponseNonNullableFields as LabelContactResponseNonNullableFields, type LabelsWrapper$1 as LabelsWrapper, type index_d$4_LastActivityUpdate as LastActivityUpdate, type index_d$4_ListContactIdsBySegmentRequest as ListContactIdsBySegmentRequest, type index_d$4_ListContactIdsBySegmentResponse as ListContactIdsBySegmentResponse, type index_d$4_ListContactsRequest as ListContactsRequest, type index_d$4_ListContactsResponse as ListContactsResponse, type index_d$4_ListFacetsRequest as ListFacetsRequest, type index_d$4_ListFacetsResponse as ListFacetsResponse, type LocationsWrapper$1 as LocationsWrapper, type index_d$4_MemberInfo as MemberInfo, index_d$4_MemberStatus as MemberStatus, type index_d$4_MergeContactsOptions as MergeContactsOptions, type index_d$4_MergeContactsRequest as MergeContactsRequest, type index_d$4_MergeContactsResponse as MergeContactsResponse, type index_d$4_MergeContactsResponseNonNullableFields as MergeContactsResponseNonNullableFields, type MessageEnvelope$4 as MessageEnvelope, type index_d$4_Metadata as Metadata, index_d$4_Mode as Mode, type Paging$3 as Paging, type PagingMetadata$2 as PagingMetadata, index_d$4_PhoneDeliverabilityStatus as PhoneDeliverabilityStatus, PhoneTag$1 as PhoneTag, type index_d$4_PreviewMergeContactsRequest as PreviewMergeContactsRequest, type index_d$4_PreviewMergeContactsResponse as PreviewMergeContactsResponse, type index_d$4_PrimaryContactInfo as PrimaryContactInfo, type index_d$4_PrimaryEmail as PrimaryEmail, type index_d$4_PrimaryPhone as PrimaryPhone, type index_d$4_PrimarySubscriptionStatus as PrimarySubscriptionStatus, index_d$4_PrivacyStatus as PrivacyStatus, type index_d$4_ProfileInfo as ProfileInfo, type Query$2 as Query, type index_d$4_QueryContactsOptions as QueryContactsOptions, type index_d$4_QueryContactsRequest as QueryContactsRequest, type index_d$4_QueryContactsResponse as QueryContactsResponse, type index_d$4_QueryContactsResponseNonNullableFields as QueryContactsResponseNonNullableFields, type index_d$4_QueryFacetsRequest as QueryFacetsRequest, type index_d$4_QueryFacetsResponse as QueryFacetsResponse, type RestoreInfo$2 as RestoreInfo, index_d$4_Role as Role, type index_d$4_Search as Search, type index_d$4_SearchContactsRequest as SearchContactsRequest, type index_d$4_SearchContactsResponse as SearchContactsResponse, type index_d$4_SearchDetails as SearchDetails, type index_d$4_SearchPagingMethodOneOf as SearchPagingMethodOneOf, type index_d$4_SegmentsWrapper as SegmentsWrapper, type index_d$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, index_d$4_SubscriptionStatus as SubscriptionStatus, type index_d$4_SyncSubmitContactRequest as SyncSubmitContactRequest, type index_d$4_SyncSubmitContactResponse as SyncSubmitContactResponse, type index_d$4_UnlabelContactRequest as UnlabelContactRequest, type index_d$4_UnlabelContactResponse as UnlabelContactResponse, type index_d$4_UnlabelContactResponseNonNullableFields as UnlabelContactResponseNonNullableFields, type index_d$4_UpdateContactOptions as UpdateContactOptions, type index_d$4_UpdateContactRequest as UpdateContactRequest, type index_d$4_UpdateContactResponse as UpdateContactResponse, type index_d$4_UpdateContactResponseNonNullableFields as UpdateContactResponseNonNullableFields, type index_d$4_UpsertContactRequest as UpsertContactRequest, type index_d$4_UpsertContactResponse as UpsertContactResponse, index_d$4_UpsertContactResponseAction as UpsertContactResponseAction, type index_d$4_UserInfo as UserInfo, WebhookIdentityType$4 as WebhookIdentityType, type index_d$4__publicOnContactCreatedType as _publicOnContactCreatedType, type index_d$4__publicOnContactDeletedType as _publicOnContactDeletedType, type index_d$4__publicOnContactMergedType as _publicOnContactMergedType, type index_d$4__publicOnContactUpdatedType as _publicOnContactUpdatedType, index_d$4_createContact as createContact, index_d$4_deleteContact as deleteContact, index_d$4_getContact as getContact, index_d$4_labelContact as labelContact, index_d$4_mergeContacts as mergeContacts, index_d$4_onContactCreated as onContactCreated, index_d$4_onContactDeleted as onContactDeleted, index_d$4_onContactMerged as onContactMerged, index_d$4_onContactUpdated as onContactUpdated, onContactCreated$1 as publicOnContactCreated, onContactDeleted$1 as publicOnContactDeleted, onContactMerged$1 as publicOnContactMerged, onContactUpdated$1 as publicOnContactUpdated, index_d$4_queryContacts as queryContacts, index_d$4_unlabelContact as unlabelContact, index_d$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> = {
@@ -2876,24 +3787,415 @@ type APIMetadata$3 = {
     packageName?: string;
 };
 type BuildRESTFunction$3<T extends RESTFunctionDescriptor$3> = T extends RESTFunctionDescriptor$3<infer U> ? U : never;
-type EventDefinition$2<Payload = unknown, Type extends string = string> = {
+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$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;
+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;
 
-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;
+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 {
     /**
@@ -3566,17 +4868,17 @@ interface QueryExtendedFieldsSignature {
      */
     (): FieldsQueryBuilder;
 }
-declare const onExtendedFieldCreated$1: EventDefinition$2<ExtendedFieldCreatedEnvelope, "wix.contacts.v4.extended-field_created">;
-declare const onExtendedFieldUpdated$1: EventDefinition$2<ExtendedFieldUpdatedEnvelope, "wix.contacts.v4.extended-field_updated">;
-declare const onExtendedFieldDeleted$1: EventDefinition$2<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$2<any, string>>(eventDefinition: T): BuildEventDefinition$2<T> & T;
+declare function createEventModule$2<T extends EventDefinition$3<any, string>>(eventDefinition: T): BuildEventDefinition$3<T> & T;
 
-declare const findOrCreateExtendedField: BuildRESTFunction$3<typeof findOrCreateExtendedField$1> & typeof findOrCreateExtendedField$1;
-declare const getExtendedField: BuildRESTFunction$3<typeof getExtendedField$1> & typeof getExtendedField$1;
-declare const renameExtendedField: BuildRESTFunction$3<typeof renameExtendedField$1> & typeof renameExtendedField$1;
-declare const deleteExtendedField: BuildRESTFunction$3<typeof deleteExtendedField$1> & typeof deleteExtendedField$1;
-declare const queryExtendedFields: BuildRESTFunction$3<typeof queryExtendedFields$1> & typeof queryExtendedFields$1;
+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;
 /**
@@ -3641,11 +4943,54 @@ declare namespace index_d$3 {
   export { type ActionEvent$2 as ActionEvent, type BaseEventMetadata$2 as BaseEventMetadata, type index_d$3_DeleteExtendedFieldRequest as DeleteExtendedFieldRequest, type index_d$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 index_d$3_ExtendedField as ExtendedField, type index_d$3_ExtendedFieldCreatedEnvelope as ExtendedFieldCreatedEnvelope, type index_d$3_ExtendedFieldDeletedEnvelope as ExtendedFieldDeletedEnvelope, type index_d$3_ExtendedFieldNonNullableFields as ExtendedFieldNonNullableFields, type index_d$3_ExtendedFieldUpdatedEnvelope as ExtendedFieldUpdatedEnvelope, index_d$3_FieldDataType as FieldDataType, index_d$3_FieldType as FieldType, type index_d$3_FieldsQueryBuilder as FieldsQueryBuilder, type index_d$3_FieldsQueryResult as FieldsQueryResult, type index_d$3_FindOrCreateExtendedFieldRequest as FindOrCreateExtendedFieldRequest, type index_d$3_FindOrCreateExtendedFieldResponse as FindOrCreateExtendedFieldResponse, type index_d$3_FindOrCreateExtendedFieldResponseNonNullableFields as FindOrCreateExtendedFieldResponseNonNullableFields, type GdprListRequest$1 as GdprListRequest, type GdprListResponse$1 as GdprListResponse, type index_d$3_GetExtendedFieldByLegacyIdRequest as GetExtendedFieldByLegacyIdRequest, type index_d$3_GetExtendedFieldByLegacyIdResponse as GetExtendedFieldByLegacyIdResponse, type index_d$3_GetExtendedFieldRequest as GetExtendedFieldRequest, type index_d$3_GetExtendedFieldResponse as GetExtendedFieldResponse, type index_d$3_GetExtendedFieldResponseNonNullableFields as GetExtendedFieldResponseNonNullableFields, type IdentificationData$3 as IdentificationData, type IdentificationDataIdOneOf$3 as IdentificationDataIdOneOf, type index_d$3_ListExtendedFieldsRequest as ListExtendedFieldsRequest, type index_d$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 index_d$3_QueryExtendedFieldsRequest as QueryExtendedFieldsRequest, type index_d$3_QueryExtendedFieldsResponse as QueryExtendedFieldsResponse, type index_d$3_QueryExtendedFieldsResponseNonNullableFields as QueryExtendedFieldsResponseNonNullableFields, type index_d$3_RenameExtendedField as RenameExtendedField, type RestoreInfo$1 as RestoreInfo, SortOrder$2 as SortOrder, type Sorting$2 as Sorting, type index_d$3_UpdateExtendedFieldRequest as UpdateExtendedFieldRequest, type index_d$3_UpdateExtendedFieldResponse as UpdateExtendedFieldResponse, type index_d$3_UpdateExtendedFieldResponseNonNullableFields as UpdateExtendedFieldResponseNonNullableFields, WebhookIdentityType$3 as WebhookIdentityType, type index_d$3__publicOnExtendedFieldCreatedType as _publicOnExtendedFieldCreatedType, type index_d$3__publicOnExtendedFieldDeletedType as _publicOnExtendedFieldDeletedType, type index_d$3__publicOnExtendedFieldUpdatedType as _publicOnExtendedFieldUpdatedType, index_d$3_deleteExtendedField as deleteExtendedField, index_d$3_findOrCreateExtendedField as findOrCreateExtendedField, index_d$3_getExtendedField as getExtendedField, index_d$3_onExtendedFieldCreated as onExtendedFieldCreated, index_d$3_onExtendedFieldDeleted as onExtendedFieldDeleted, index_d$3_onExtendedFieldUpdated as onExtendedFieldUpdated, onExtendedFieldCreated$1 as publicOnExtendedFieldCreated, onExtendedFieldDeleted$1 as publicOnExtendedFieldDeleted, onExtendedFieldUpdated$1 as publicOnExtendedFieldUpdated, index_d$3_queryExtendedFields as queryExtendedFields, index_d$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> = {
@@ -3667,16 +5012,65 @@ type APIMetadata$2 = {
     packageName?: string;
 };
 type BuildRESTFunction$2<T extends RESTFunctionDescriptor$2> = T extends RESTFunctionDescriptor$2<infer U> ? U : never;
-type EventDefinition$1<Payload = unknown, Type extends string = string> = {
+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$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;
+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.
@@ -3685,6 +5079,348 @@ declare global {
 	}
 }
 
+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: {};
+}
+
+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$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];
+
+/**
+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>
+>;
+
+/**
+ * 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$2 = RESTFunctionDescriptor$2 | AmbassadorFunctionDescriptor$2 | HostModule$2<any, any> | EventDefinition$2<any> | ServicePluginDefinition$2<any> | {
+    [key: string]: Descriptors$2 | PublicMetadata$2 | 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$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;
+};
+
+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 {
     /**
@@ -4369,17 +6105,17 @@ interface QueryLabelsSignature {
      */
     (options?: QueryLabelsOptions | undefined): LabelsQueryBuilder;
 }
-declare const onLabelCreated$1: EventDefinition$1<LabelCreatedEnvelope, "wix.contacts.v4.label_created">;
-declare const onLabelUpdated$1: EventDefinition$1<LabelUpdatedEnvelope, "wix.contacts.v4.label_updated">;
-declare const onLabelDeleted$1: EventDefinition$1<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$1<any, string>>(eventDefinition: T): BuildEventDefinition$1<T> & T;
+declare function createEventModule$1<T extends EventDefinition$2<any, string>>(eventDefinition: T): BuildEventDefinition$2<T> & T;
 
-declare const findOrCreateLabel: BuildRESTFunction$2<typeof findOrCreateLabel$1> & typeof findOrCreateLabel$1;
-declare const getLabel: BuildRESTFunction$2<typeof getLabel$1> & typeof getLabel$1;
-declare const renameLabel: BuildRESTFunction$2<typeof renameLabel$1> & typeof renameLabel$1;
-declare const deleteLabel: BuildRESTFunction$2<typeof deleteLabel$1> & typeof deleteLabel$1;
-declare const queryLabels: BuildRESTFunction$2<typeof queryLabels$1> & typeof queryLabels$1;
+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;
 /**
@@ -4457,11 +6193,54 @@ declare namespace index_d$2 {
   export { type ActionEvent$1 as ActionEvent, type BaseEventMetadata$1 as BaseEventMetadata, type index_d$2_ContactLabel as ContactLabel, type index_d$2_ContactLabelNamespace as ContactLabelNamespace, type index_d$2_ContactLabelNonNullableFields as ContactLabelNonNullableFields, type index_d$2_DeleteLabelRequest as DeleteLabelRequest, type index_d$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 index_d$2_FindOrCreateLabelOptions as FindOrCreateLabelOptions, type index_d$2_FindOrCreateLabelRequest as FindOrCreateLabelRequest, type index_d$2_FindOrCreateLabelResponse as FindOrCreateLabelResponse, type index_d$2_FindOrCreateLabelResponseNonNullableFields as FindOrCreateLabelResponseNonNullableFields, type index_d$2_GdprListRequest as GdprListRequest, type index_d$2_GdprListResponse as GdprListResponse, type index_d$2_GetLabelByLegacyIdRequest as GetLabelByLegacyIdRequest, type index_d$2_GetLabelByLegacyIdResponse as GetLabelByLegacyIdResponse, type index_d$2_GetLabelOptions as GetLabelOptions, type index_d$2_GetLabelRequest as GetLabelRequest, type index_d$2_GetLabelResponse as GetLabelResponse, type index_d$2_GetLabelResponseNonNullableFields as GetLabelResponseNonNullableFields, type IdentificationData$2 as IdentificationData, type IdentificationDataIdOneOf$2 as IdentificationDataIdOneOf, type index_d$2_LabelCreatedEnvelope as LabelCreatedEnvelope, type index_d$2_LabelDeletedEnvelope as LabelDeletedEnvelope, index_d$2_LabelType as LabelType, type index_d$2_LabelUpdatedEnvelope as LabelUpdatedEnvelope, type index_d$2_LabelsQueryBuilder as LabelsQueryBuilder, type index_d$2_LabelsQueryResult as LabelsQueryResult, type index_d$2_LabelsQuotaReached as LabelsQuotaReached, type index_d$2_ListLabelNamespacesRequest as ListLabelNamespacesRequest, type index_d$2_ListLabelNamespacesResponse as ListLabelNamespacesResponse, type index_d$2_ListLabelsRequest as ListLabelsRequest, type index_d$2_ListLabelsResponse as ListLabelsResponse, type MessageEnvelope$2 as MessageEnvelope, type Paging$1 as Paging, type index_d$2_PagingMetadata as PagingMetadata, type index_d$2_PurgeRequest as PurgeRequest, type index_d$2_PurgeResponse as PurgeResponse, type index_d$2_Query as Query, type index_d$2_QueryLabelsOptions as QueryLabelsOptions, type index_d$2_QueryLabelsRequest as QueryLabelsRequest, type index_d$2_QueryLabelsResponse as QueryLabelsResponse, type index_d$2_QueryLabelsResponseNonNullableFields as QueryLabelsResponseNonNullableFields, type index_d$2_RenameLabel as RenameLabel, type index_d$2_RenameLabelOptions as RenameLabelOptions, type index_d$2_RestoreInfo as RestoreInfo, SortOrder$1 as SortOrder, type Sorting$1 as Sorting, type index_d$2_UpdateLabelRequest as UpdateLabelRequest, type index_d$2_UpdateLabelResponse as UpdateLabelResponse, type index_d$2_UpdateLabelResponseNonNullableFields as UpdateLabelResponseNonNullableFields, WebhookIdentityType$2 as WebhookIdentityType, type index_d$2__publicOnLabelCreatedType as _publicOnLabelCreatedType, type index_d$2__publicOnLabelDeletedType as _publicOnLabelDeletedType, type index_d$2__publicOnLabelUpdatedType as _publicOnLabelUpdatedType, index_d$2_deleteLabel as deleteLabel, index_d$2_findOrCreateLabel as findOrCreateLabel, index_d$2_getLabel as getLabel, index_d$2_onLabelCreated as onLabelCreated, index_d$2_onLabelDeleted as onLabelDeleted, index_d$2_onLabelUpdated as onLabelUpdated, onLabelCreated$1 as publicOnLabelCreated, onLabelDeleted$1 as publicOnLabelDeleted, onLabelUpdated$1 as publicOnLabelUpdated, index_d$2_queryLabels as queryLabels, index_d$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> = {
@@ -4483,6 +6262,65 @@ type APIMetadata$1 = {
     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.
@@ -4491,6 +6329,348 @@ declare global {
 	}
 }
 
+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: {};
+}
+
+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$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];
+
+/**
+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>
+>;
+
+/**
+ * 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$1 = RESTFunctionDescriptor$1 | AmbassadorFunctionDescriptor$1 | HostModule$1<any, any> | EventDefinition$1<any> | ServicePluginDefinition$1<any> | {
+    [key: string]: Descriptors$1 | PublicMetadata$1 | 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$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;
+};
+
+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 {
     /** Submit Contact Id */
@@ -5090,7 +7270,7 @@ interface AppendOrCreateContactSignature {
     (options?: AppendOrCreateContactOptions | undefined): Promise<SubmitContactResponse & SubmitContactResponseNonNullableFields>;
 }
 
-declare const appendOrCreateContact: BuildRESTFunction$1<typeof appendOrCreateContact$1> & typeof appendOrCreateContact$1;
+declare const appendOrCreateContact: MaybeContext$1<BuildRESTFunction$1<typeof appendOrCreateContact$1> & typeof appendOrCreateContact$1>;
 
 type index_d$1_ActivityIcon = ActivityIcon;
 type index_d$1_Address = Address;
@@ -5143,11 +7323,54 @@ declare namespace index_d$1 {
   export { type index_d$1_ActivityIcon as ActivityIcon, type index_d$1_Address as Address, type index_d$1_AddressLocation as AddressLocation, type index_d$1_AddressStreetOneOf as AddressStreetOneOf, index_d$1_AddressTag as AddressTag, type index_d$1_AppendOrCreateContactOptions as AppendOrCreateContactOptions, type index_d$1_AssigneesWrapper as AssigneesWrapper, type index_d$1_ContactActivity as ContactActivity, index_d$1_ContactActivityType as ContactActivityType, type index_d$1_ContactAddress as ContactAddress, type index_d$1_ContactAddressesWrapper as ContactAddressesWrapper, type index_d$1_ContactEmail as ContactEmail, type index_d$1_ContactEmailsWrapper as ContactEmailsWrapper, type ContactInfo$1 as ContactInfo, type index_d$1_ContactName as ContactName, type index_d$1_ContactPhone as ContactPhone, type index_d$1_ContactPhonesWrapper as ContactPhonesWrapper, type index_d$1_ContactPicture as ContactPicture, index_d$1_ContactSourceType as ContactSourceType, type index_d$1_ContactToSubmit as ContactToSubmit, index_d$1_EmailTag as EmailTag, type index_d$1_ExtendedFieldsWrapper as ExtendedFieldsWrapper, type IdentificationData$1 as IdentificationData, type IdentificationDataIdOneOf$1 as IdentificationDataIdOneOf, index_d$1_IdentityType as IdentityType, index_d$1_ImageProvider as ImageProvider, type index_d$1_LabelsWrapper as LabelsWrapper, type index_d$1_LocationsWrapper as LocationsWrapper, type MessageEnvelope$1 as MessageEnvelope, index_d$1_PhoneTag as PhoneTag, type index_d$1_StreetAddress as StreetAddress, type index_d$1_Subdivision as Subdivision, index_d$1_SubdivisionType as SubdivisionType, type index_d$1_SubmitContact as SubmitContact, type index_d$1_SubmitContactOptions as SubmitContactOptions, type index_d$1_SubmitContactRequest as SubmitContactRequest, type index_d$1_SubmitContactResponse as SubmitContactResponse, type index_d$1_SubmitContactResponseNonNullableFields as SubmitContactResponseNonNullableFields, index_d$1_SubmitOperation as SubmitOperation, type index_d$1_SubmitVisitorIdRequest as SubmitVisitorIdRequest, type index_d$1_SubmitVisitorIdResponse as SubmitVisitorIdResponse, WebhookIdentityType$1 as WebhookIdentityType, index_d$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> = {
@@ -5180,6 +7403,55 @@ declare function EventDefinition<Type extends string>(type: Type, isDomainEvent?
 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 {
@@ -5187,6 +7459,348 @@ declare global {
 	}
 }
 
+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.
@@ -5921,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;
 /**