@wix/blog 1.0.289 → 1.0.290

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

@@ -1,39 +1,127 @@
-type RESTFunctionDescriptor<T extends (...args: any[]) => any = (...args: any[]) => any> = (httpClient: HttpClient) => T;
-interface HttpClient {
-    request<TResponse, TData = any>(req: RequestOptionsFactory<TResponse, TData>): Promise<HttpResponse<TResponse>>;
+type HostModule$5<T, H extends Host$5> = {
+    __type: 'host';
+    create(host: H): T;
+};
+type HostModuleAPI$5<T extends HostModule$5<any, any>> = T extends HostModule$5<infer U, any> ? U : never;
+type Host$5<Environment = unknown> = {
+    channel: {
+        observeState(callback: (props: unknown, environment: Environment) => unknown): {
+            disconnect: () => void;
+        } | Promise<{
+            disconnect: () => void;
+        }>;
+    };
+    environment?: Environment;
+    /**
+     * Optional bast url to use for API requests, for example `www.wixapis.com`
+     */
+    apiBaseUrl?: string;
+    /**
+     * Possible data to be provided by every host, for cross cutting concerns
+     * like internationalization, billing, etc.
+     */
+    essentials?: {
+        /**
+         * The language of the currently viewed session
+         */
+        language?: string;
+        /**
+         * The locale of the currently viewed session
+         */
+        locale?: string;
+        /**
+         * Any headers that should be passed through to the API requests
+         */
+        passThroughHeaders?: Record<string, string>;
+    };
+};
+
+type RESTFunctionDescriptor$5<T extends (...args: any[]) => any = (...args: any[]) => any> = (httpClient: HttpClient$5) => T;
+interface HttpClient$5 {
+    request<TResponse, TData = any>(req: RequestOptionsFactory$5<TResponse, TData>): Promise<HttpResponse$5<TResponse>>;
     fetchWithAuth: typeof fetch;
     wixAPIFetch: (relativeUrl: string, options: RequestInit) => Promise<Response>;
+    getActiveToken?: () => string | undefined;
 }
-type RequestOptionsFactory<TResponse = any, TData = any> = (context: any) => RequestOptions<TResponse, TData>;
-type HttpResponse<T = any> = {
+type RequestOptionsFactory$5<TResponse = any, TData = any> = (context: any) => RequestOptions$5<TResponse, TData>;
+type HttpResponse$5<T = any> = {
     data: T;
     status: number;
     statusText: string;
     headers: any;
     request?: any;
 };
-type RequestOptions<_TResponse = any, Data = any> = {
+type RequestOptions$5<_TResponse = any, Data = any> = {
     method: 'POST' | 'GET' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
     url: string;
     data?: Data;
     params?: URLSearchParams;
-} & APIMetadata;
-type APIMetadata = {
+} & APIMetadata$5;
+type APIMetadata$5 = {
     methodFqn?: string;
     entityFqdn?: string;
     packageName?: string;
 };
-type BuildRESTFunction<T extends RESTFunctionDescriptor> = T extends RESTFunctionDescriptor<infer U> ? U : never;
-type EventDefinition<Payload = unknown, Type extends string = string> = {
+type BuildRESTFunction$5<T extends RESTFunctionDescriptor$5> = T extends RESTFunctionDescriptor$5<infer U> ? U : never;
+type EventDefinition$9<Payload = unknown, Type extends string = string> = {
     __type: 'event-definition';
     type: Type;
     isDomainEvent?: boolean;
     transformations?: (envelope: unknown) => Payload;
     __payload: Payload;
 };
-declare function EventDefinition<Type extends string>(type: Type, isDomainEvent?: boolean, transformations?: (envelope: any) => unknown): <Payload = unknown>() => EventDefinition<Payload, Type>;
-type EventHandler<T extends EventDefinition> = (payload: T['__payload']) => void | Promise<void>;
-type BuildEventDefinition<T extends EventDefinition<any, string>> = (handler: EventHandler<T>) => void;
+declare function EventDefinition$9<Type extends string>(type: Type, isDomainEvent?: boolean, transformations?: (envelope: any) => unknown): <Payload = unknown>() => EventDefinition$9<Payload, Type>;
+type EventHandler$9<T extends EventDefinition$9> = (payload: T['__payload']) => void | Promise<void>;
+type BuildEventDefinition$9<T extends EventDefinition$9<any, string>> = (handler: EventHandler$9<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 +130,284 @@ 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>>
+	: {});
+
+/**
+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> = NonNullable<
+// Wrap in `NonNullable` to strip away the `undefined` type from the produced union.
+{
+	// 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 since the condition passes.
+		? 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$9<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$9<any> ? BuildEventDefinition$9<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;
+
 /** BlogCache is the main entity of BlogCacheService */
 interface BlogCache {
     /**
@@ -748,7 +1114,7 @@ interface GetBlogCacheResponseNonNullableFields {
     blogCache?: BlogCacheNonNullableFields;
 }
 
-declare function getBlogCache$1(httpClient: HttpClient): GetBlogCacheSignature;
+declare function getBlogCache$1(httpClient: HttpClient$5): GetBlogCacheSignature;
 interface GetBlogCacheSignature {
     /**
      * Gets blog cache.
@@ -756,7 +1122,7 @@ interface GetBlogCacheSignature {
     (): Promise<GetBlogCacheResponse & GetBlogCacheResponseNonNullableFields>;
 }
 
-declare const getBlogCache: BuildRESTFunction<typeof getBlogCache$1> & typeof getBlogCache$1;
+declare const getBlogCache: MaybeContext$5<BuildRESTFunction$5<typeof getBlogCache$1> & typeof getBlogCache$1>;
 
 type context$5_Address = Address;
 type context$5_AddressHint = AddressHint;
@@ -803,6 +1169,416 @@ declare namespace context$5 {
   export { type ActionEvent$4 as ActionEvent, type context$5_Address as Address, type context$5_AddressHint as AddressHint, type context$5_BlogCache as BlogCache, type context$5_BusinessSchedule as BusinessSchedule, type context$5_Categories as Categories, type context$5_ChangeContext as ChangeContext, type context$5_ChangeContextPayloadOneOf as ChangeContextPayloadOneOf, type context$5_ConsentPolicy as ConsentPolicy, context$5_DayOfWeek as DayOfWeek, type DomainEvent$4 as DomainEvent, type DomainEventBodyOneOf$4 as DomainEventBodyOneOf, type context$5_Empty as Empty, type EntityCreatedEvent$4 as EntityCreatedEvent, type EntityDeletedEvent$4 as EntityDeletedEvent, type EntityUpdatedEvent$4 as EntityUpdatedEvent, context$5_Flag as Flag, type context$5_GeoCoordinates as GeoCoordinates, type context$5_GetBlogCacheRequest as GetBlogCacheRequest, type context$5_GetBlogCacheResponse as GetBlogCacheResponse, type context$5_GetBlogCacheResponseNonNullableFields as GetBlogCacheResponseNonNullableFields, type context$5_Locale as Locale, context$5_LocaleStatus as LocaleStatus, type context$5_Multilingual as Multilingual, type context$5_PageInfo as PageInfo, type context$5_PagesData as PagesData, context$5_PlacementType as PlacementType, type context$5_Properties as Properties, type context$5_PropertiesChange as PropertiesChange, context$5_ResolutionMethod as ResolutionMethod, type RestoreInfo$4 as RestoreInfo, type context$5_SiteCloned as SiteCloned, type context$5_SiteCreated as SiteCreated, type context$5_SiteProperties as SiteProperties, type context$5_SitePropertiesEvent as SitePropertiesEvent, type context$5_SitePropertiesNotification as SitePropertiesNotification, type context$5_SiteSupportedLanguage as SiteSupportedLanguage, type context$5_SpecialHourPeriod as SpecialHourPeriod, type context$5_SupportedLanguage as SupportedLanguage, type context$5_TimePeriod as TimePeriod, type context$5_Translation as Translation, type context$5_UrlInvalidationNotification as UrlInvalidationNotification, context$5_getBlogCache as getBlogCache };
 }
 
+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 bast url to use for API requests, for example `www.wixapis.com`
+     */
+    apiBaseUrl?: string;
+    /**
+     * Possible data to be provided by every host, for cross cutting concerns
+     * like internationalization, billing, etc.
+     */
+    essentials?: {
+        /**
+         * The language of the currently viewed session
+         */
+        language?: string;
+        /**
+         * The locale of the currently viewed session
+         */
+        locale?: string;
+        /**
+         * Any headers that should be passed through to the API requests
+         */
+        passThroughHeaders?: Record<string, string>;
+    };
+};
+
+type RESTFunctionDescriptor$4<T extends (...args: any[]) => any = (...args: any[]) => any> = (httpClient: HttpClient$4) => T;
+interface HttpClient$4 {
+    request<TResponse, TData = any>(req: RequestOptionsFactory$4<TResponse, TData>): Promise<HttpResponse$4<TResponse>>;
+    fetchWithAuth: typeof fetch;
+    wixAPIFetch: (relativeUrl: string, options: RequestInit) => Promise<Response>;
+    getActiveToken?: () => string | undefined;
+}
+type RequestOptionsFactory$4<TResponse = any, TData = any> = (context: any) => RequestOptions$4<TResponse, TData>;
+type HttpResponse$4<T = any> = {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: any;
+    request?: any;
+};
+type RequestOptions$4<_TResponse = any, Data = any> = {
+    method: 'POST' | 'GET' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+    url: string;
+    data?: Data;
+    params?: URLSearchParams;
+} & APIMetadata$4;
+type APIMetadata$4 = {
+    methodFqn?: string;
+    entityFqdn?: string;
+    packageName?: string;
+};
+type BuildRESTFunction$4<T extends RESTFunctionDescriptor$4> = T extends RESTFunctionDescriptor$4<infer U> ? U : never;
+type EventDefinition$8<Payload = unknown, Type extends string = string> = {
+    __type: 'event-definition';
+    type: Type;
+    isDomainEvent?: boolean;
+    transformations?: (envelope: unknown) => Payload;
+    __payload: Payload;
+};
+declare function EventDefinition$8<Type extends string>(type: Type, isDomainEvent?: boolean, transformations?: (envelope: any) => unknown): <Payload = unknown>() => EventDefinition$8<Payload, Type>;
+type EventHandler$8<T extends EventDefinition$8> = (payload: T['__payload']) => void | Promise<void>;
+type BuildEventDefinition$8<T extends EventDefinition$8<any, string>> = (handler: EventHandler$8<T>) => void;
+
+type ServicePluginMethodInput$4 = {
+    request: any;
+    metadata: any;
+};
+type ServicePluginContract$4 = Record<string, (payload: ServicePluginMethodInput$4) => unknown | Promise<unknown>>;
+type ServicePluginMethodMetadata$4 = {
+    name: string;
+    primaryHttpMappingPath: string;
+    transformations: {
+        fromREST: (...args: unknown[]) => ServicePluginMethodInput$4;
+        toREST: (...args: unknown[]) => unknown;
+    };
+};
+type ServicePluginDefinition$4<Contract extends ServicePluginContract$4> = {
+    __type: 'service-plugin-definition';
+    componentType: string;
+    methods: ServicePluginMethodMetadata$4[];
+    __contract: Contract;
+};
+declare function ServicePluginDefinition$4<Contract extends ServicePluginContract$4>(componentType: string, methods: ServicePluginMethodMetadata$4[]): ServicePluginDefinition$4<Contract>;
+type BuildServicePluginDefinition$4<T extends ServicePluginDefinition$4<any>> = (implementation: T['__contract']) => void;
+declare const SERVICE_PLUGIN_ERROR_TYPE$4 = "wix_spi_error";
+
+type RequestContext$4 = {
+    isSSR: boolean;
+    host: string;
+    protocol?: string;
+};
+type ResponseTransformer$4 = (data: any, headers?: any) => any;
+/**
+ * Ambassador request options types are copied mostly from AxiosRequestConfig.
+ * They are copied and not imported to reduce the amount of dependencies (to reduce install time).
+ * https://github.com/axios/axios/blob/3f53eb6960f05a1f88409c4b731a40de595cb825/index.d.ts#L307-L315
+ */
+type Method$4 = 'get' | 'GET' | 'delete' | 'DELETE' | 'head' | 'HEAD' | 'options' | 'OPTIONS' | 'post' | 'POST' | 'put' | 'PUT' | 'patch' | 'PATCH' | 'purge' | 'PURGE' | 'link' | 'LINK' | 'unlink' | 'UNLINK';
+type AmbassadorRequestOptions$4<T = any> = {
+    _?: T;
+    url?: string;
+    method?: Method$4;
+    params?: any;
+    data?: any;
+    transformResponse?: ResponseTransformer$4 | ResponseTransformer$4[];
+};
+type AmbassadorFactory$4<Request, Response> = (payload: Request) => ((context: RequestContext$4) => AmbassadorRequestOptions$4<Response>) & {
+    __isAmbassador: boolean;
+};
+type AmbassadorFunctionDescriptor$4<Request = any, Response = any> = AmbassadorFactory$4<Request, Response>;
+type BuildAmbassadorFunction$4<T extends AmbassadorFunctionDescriptor$4> = T extends AmbassadorFunctionDescriptor$4<infer Request, infer Response> ? (req: Request) => Promise<Response> : never;
+
+declare global {
+	// eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
+	interface SymbolConstructor {
+		readonly observable: symbol;
+	}
+}
+
+declare const emptyObjectSymbol$4: unique symbol;
+
+/**
+Represents a strictly empty plain object, the `{}` value.
+
+When you annotate something as the type `{}`, it can be anything except `null` and `undefined`. This means that you cannot use `{}` to represent an empty plain object ([read more](https://stackoverflow.com/questions/47339869/typescript-empty-object-and-any-difference/52193484#52193484)).
+
+@example
+```
+import type {EmptyObject} from 'type-fest';
+
+// The following illustrates the problem with `{}`.
+const foo1: {} = {}; // Pass
+const foo2: {} = []; // Pass
+const foo3: {} = 42; // Pass
+const foo4: {} = {a: 1}; // Pass
+
+// With `EmptyObject` only the first case is valid.
+const bar1: EmptyObject = {}; // Pass
+const bar2: EmptyObject = 42; // Fail
+const bar3: EmptyObject = []; // Fail
+const bar4: EmptyObject = {a: 1}; // Fail
+```
+
+Unfortunately, `Record<string, never>`, `Record<keyof any, never>` and `Record<never, never>` do not work. See {@link https://github.com/sindresorhus/type-fest/issues/395 #395}.
+
+@category Object
+*/
+type EmptyObject$4 = {[emptyObjectSymbol$4]?: never};
+
+/**
+Returns a boolean for whether the two given types are equal.
+
+@link https://github.com/microsoft/TypeScript/issues/27024#issuecomment-421529650
+@link https://stackoverflow.com/questions/68961864/how-does-the-equals-work-in-typescript/68963796#68963796
+
+Use-cases:
+- If you want to make a conditional branch based on the result of a comparison of two types.
+
+@example
+```
+import type {IsEqual} from 'type-fest';
+
+// This type returns a boolean for whether the given array includes the given item.
+// `IsEqual` is used to compare the given array at position 0 and the given item and then return true if they are equal.
+type Includes<Value extends readonly any[], Item> =
+	Value extends readonly [Value[0], ...infer rest]
+		? IsEqual<Value[0], Item> extends true
+			? true
+			: Includes<rest, Item>
+		: false;
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsEqual$4<A, B> =
+	(<G>() => G extends A ? 1 : 2) extends
+	(<G>() => G extends B ? 1 : 2)
+		? true
+		: false;
+
+/**
+Filter out keys from an object.
+
+Returns `never` if `Exclude` is strictly equal to `Key`.
+Returns `never` if `Key` extends `Exclude`.
+Returns `Key` otherwise.
+
+@example
+```
+type Filtered = Filter<'foo', 'foo'>;
+//=> never
+```
+
+@example
+```
+type Filtered = Filter<'bar', string>;
+//=> never
+```
+
+@example
+```
+type Filtered = Filter<'bar', 'foo'>;
+//=> 'bar'
+```
+
+@see {Except}
+*/
+type Filter$4<KeyType, ExcludeType> = IsEqual$4<KeyType, ExcludeType> extends true ? never : (KeyType extends ExcludeType ? never : KeyType);
+
+type ExceptOptions$4 = {
+	/**
+	Disallow assigning non-specified properties.
+
+	Note that any omitted properties in the resulting type will be present in autocomplete as `undefined`.
+
+	@default false
+	*/
+	requireExactProps?: boolean;
+};
+
+/**
+Create a type from an object type without certain keys.
+
+We recommend setting the `requireExactProps` option to `true`.
+
+This type is a stricter version of [`Omit`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-5.html#the-omit-helper-type). The `Omit` type does not restrict the omitted keys to be keys present on the given type, while `Except` does. The benefits of a stricter type are avoiding typos and allowing the compiler to pick up on rename refactors automatically.
+
+This type was proposed to the TypeScript team, which declined it, saying they prefer that libraries implement stricter versions of the built-in types ([microsoft/TypeScript#30825](https://github.com/microsoft/TypeScript/issues/30825#issuecomment-523668235)).
+
+@example
+```
+import type {Except} from 'type-fest';
+
+type Foo = {
+	a: number;
+	b: string;
+};
+
+type FooWithoutA = Except<Foo, 'a'>;
+//=> {b: string}
+
+const fooWithoutA: FooWithoutA = {a: 1, b: '2'};
+//=> errors: 'a' does not exist in type '{ b: string; }'
+
+type FooWithoutB = Except<Foo, 'b', {requireExactProps: true}>;
+//=> {a: number} & Partial<Record<"b", never>>
+
+const fooWithoutB: FooWithoutB = {a: 1, b: '2'};
+//=> errors at 'b': Type 'string' is not assignable to type 'undefined'.
+```
+
+@category Object
+*/
+type Except$4<ObjectType, KeysType extends keyof ObjectType, Options extends ExceptOptions$4 = {requireExactProps: false}> = {
+	[KeyType in keyof ObjectType as Filter$4<KeyType, KeysType>]: ObjectType[KeyType];
+} & (Options['requireExactProps'] extends true
+	? Partial<Record<KeysType, never>>
+	: {});
+
+/**
+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> = NonNullable<
+// Wrap in `NonNullable` to strip away the `undefined` type from the produced union.
+{
+	// 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 since the condition passes.
+		? 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$8<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$8<any> ? BuildEventDefinition$8<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 ImportStatus {
     /** Import Id. */
     _id?: string;
@@ -874,62 +1650,472 @@ interface GetNotImportedPostsResponseNonNullableFields {
     notImportedPosts: PostNonNullableFields$1[];
 }
 
-declare function startImport$1(httpClient: HttpClient): StartImportSignature;
-interface StartImportSignature {
-    /**
-     * Starts wordpress import process.
-     */
-    (): Promise<void>;
-}
-declare function submitUrlForImport$1(httpClient: HttpClient): SubmitUrlForImportSignature;
-interface SubmitUrlForImportSignature {
-    /**
-     * Submits wordpress import process from URL.
-     * It will prepare wordpress data for import from the given URL.
-     * Use "GetImportStatus" to get the status of the import process.
-     * Once the import status becomes READY_TO_IMPORT, the import process can be started by invoking "StartImport".
-     * @param - Url to wordpress xml file.
-     */
-    (url: string): Promise<void>;
+declare function startImport$1(httpClient: HttpClient$4): StartImportSignature;
+interface StartImportSignature {
+    /**
+     * Starts wordpress import process.
+     */
+    (): Promise<void>;
+}
+declare function submitUrlForImport$1(httpClient: HttpClient$4): SubmitUrlForImportSignature;
+interface SubmitUrlForImportSignature {
+    /**
+     * Submits wordpress import process from URL.
+     * It will prepare wordpress data for import from the given URL.
+     * Use "GetImportStatus" to get the status of the import process.
+     * Once the import status becomes READY_TO_IMPORT, the import process can be started by invoking "StartImport".
+     * @param - Url to wordpress xml file.
+     */
+    (url: string): Promise<void>;
+}
+declare function getImportStatus$1(httpClient: HttpClient$4): GetImportStatusSignature;
+interface GetImportStatusSignature {
+    /**
+     * Gets the status of the import process.
+     */
+    (): Promise<GetImportStatusResponse & GetImportStatusResponseNonNullableFields>;
+}
+declare function getNotImportedPosts$1(httpClient: HttpClient$4): GetNotImportedPostsSignature;
+interface GetNotImportedPostsSignature {
+    /**
+     * Gets the posts that were not yet imported either because of an error or because import is still in progress.
+     */
+    (): Promise<GetNotImportedPostsResponse & GetNotImportedPostsResponseNonNullableFields>;
+}
+
+declare const startImport: MaybeContext$4<BuildRESTFunction$4<typeof startImport$1> & typeof startImport$1>;
+declare const submitUrlForImport: MaybeContext$4<BuildRESTFunction$4<typeof submitUrlForImport$1> & typeof submitUrlForImport$1>;
+declare const getImportStatus: MaybeContext$4<BuildRESTFunction$4<typeof getImportStatus$1> & typeof getImportStatus$1>;
+declare const getNotImportedPosts: MaybeContext$4<BuildRESTFunction$4<typeof getNotImportedPosts$1> & typeof getNotImportedPosts$1>;
+
+type context$4_GetImportStatusRequest = GetImportStatusRequest;
+type context$4_GetImportStatusResponse = GetImportStatusResponse;
+type context$4_GetImportStatusResponseNonNullableFields = GetImportStatusResponseNonNullableFields;
+type context$4_GetNotImportedPostsRequest = GetNotImportedPostsRequest;
+type context$4_GetNotImportedPostsResponse = GetNotImportedPostsResponse;
+type context$4_GetNotImportedPostsResponseNonNullableFields = GetNotImportedPostsResponseNonNullableFields;
+type context$4_ImportStatus = ImportStatus;
+type context$4_StartImportRequest = StartImportRequest;
+type context$4_StartImportResponse = StartImportResponse;
+type context$4_SubmitUrlForImportRequest = SubmitUrlForImportRequest;
+type context$4_SubmitUrlForImportResponse = SubmitUrlForImportResponse;
+declare const context$4_getImportStatus: typeof getImportStatus;
+declare const context$4_getNotImportedPosts: typeof getNotImportedPosts;
+declare const context$4_startImport: typeof startImport;
+declare const context$4_submitUrlForImport: typeof submitUrlForImport;
+declare namespace context$4 {
+  export { type context$4_GetImportStatusRequest as GetImportStatusRequest, type context$4_GetImportStatusResponse as GetImportStatusResponse, type context$4_GetImportStatusResponseNonNullableFields as GetImportStatusResponseNonNullableFields, type context$4_GetNotImportedPostsRequest as GetNotImportedPostsRequest, type context$4_GetNotImportedPostsResponse as GetNotImportedPostsResponse, type context$4_GetNotImportedPostsResponseNonNullableFields as GetNotImportedPostsResponseNonNullableFields, type context$4_ImportStatus as ImportStatus, type Post$1 as Post, type context$4_StartImportRequest as StartImportRequest, type context$4_StartImportResponse as StartImportResponse, Status$2 as Status, type context$4_SubmitUrlForImportRequest as SubmitUrlForImportRequest, type context$4_SubmitUrlForImportResponse as SubmitUrlForImportResponse, context$4_getImportStatus as getImportStatus, context$4_getNotImportedPosts as getNotImportedPosts, context$4_startImport as startImport, context$4_submitUrlForImport as submitUrlForImport };
+}
+
+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 bast url to use for API requests, for example `www.wixapis.com`
+     */
+    apiBaseUrl?: string;
+    /**
+     * Possible data to be provided by every host, for cross cutting concerns
+     * like internationalization, billing, etc.
+     */
+    essentials?: {
+        /**
+         * The language of the currently viewed session
+         */
+        language?: string;
+        /**
+         * The locale of the currently viewed session
+         */
+        locale?: string;
+        /**
+         * Any headers that should be passed through to the API requests
+         */
+        passThroughHeaders?: Record<string, string>;
+    };
+};
+
+type RESTFunctionDescriptor$3<T extends (...args: any[]) => any = (...args: any[]) => any> = (httpClient: HttpClient$3) => T;
+interface HttpClient$3 {
+    request<TResponse, TData = any>(req: RequestOptionsFactory$3<TResponse, TData>): Promise<HttpResponse$3<TResponse>>;
+    fetchWithAuth: typeof fetch;
+    wixAPIFetch: (relativeUrl: string, options: RequestInit) => Promise<Response>;
+    getActiveToken?: () => string | undefined;
+}
+type RequestOptionsFactory$3<TResponse = any, TData = any> = (context: any) => RequestOptions$3<TResponse, TData>;
+type HttpResponse$3<T = any> = {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: any;
+    request?: any;
+};
+type RequestOptions$3<_TResponse = any, Data = any> = {
+    method: 'POST' | 'GET' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+    url: string;
+    data?: Data;
+    params?: URLSearchParams;
+} & APIMetadata$3;
+type APIMetadata$3 = {
+    methodFqn?: string;
+    entityFqdn?: string;
+    packageName?: string;
+};
+type BuildRESTFunction$3<T extends RESTFunctionDescriptor$3> = T extends RESTFunctionDescriptor$3<infer U> ? U : never;
+type EventDefinition$7<Payload = unknown, Type extends string = string> = {
+    __type: 'event-definition';
+    type: Type;
+    isDomainEvent?: boolean;
+    transformations?: (envelope: unknown) => Payload;
+    __payload: Payload;
+};
+declare function EventDefinition$7<Type extends string>(type: Type, isDomainEvent?: boolean, transformations?: (envelope: any) => unknown): <Payload = unknown>() => EventDefinition$7<Payload, Type>;
+type EventHandler$7<T extends EventDefinition$7> = (payload: T['__payload']) => void | Promise<void>;
+type BuildEventDefinition$7<T extends EventDefinition$7<any, string>> = (handler: EventHandler$7<T>) => void;
+
+type ServicePluginMethodInput$3 = {
+    request: any;
+    metadata: any;
+};
+type ServicePluginContract$3 = Record<string, (payload: ServicePluginMethodInput$3) => unknown | Promise<unknown>>;
+type ServicePluginMethodMetadata$3 = {
+    name: string;
+    primaryHttpMappingPath: string;
+    transformations: {
+        fromREST: (...args: unknown[]) => ServicePluginMethodInput$3;
+        toREST: (...args: unknown[]) => unknown;
+    };
+};
+type ServicePluginDefinition$3<Contract extends ServicePluginContract$3> = {
+    __type: 'service-plugin-definition';
+    componentType: string;
+    methods: ServicePluginMethodMetadata$3[];
+    __contract: Contract;
+};
+declare function ServicePluginDefinition$3<Contract extends ServicePluginContract$3>(componentType: string, methods: ServicePluginMethodMetadata$3[]): ServicePluginDefinition$3<Contract>;
+type BuildServicePluginDefinition$3<T extends ServicePluginDefinition$3<any>> = (implementation: T['__contract']) => void;
+declare const SERVICE_PLUGIN_ERROR_TYPE$3 = "wix_spi_error";
+
+type RequestContext$3 = {
+    isSSR: boolean;
+    host: string;
+    protocol?: string;
+};
+type ResponseTransformer$3 = (data: any, headers?: any) => any;
+/**
+ * Ambassador request options types are copied mostly from AxiosRequestConfig.
+ * They are copied and not imported to reduce the amount of dependencies (to reduce install time).
+ * https://github.com/axios/axios/blob/3f53eb6960f05a1f88409c4b731a40de595cb825/index.d.ts#L307-L315
+ */
+type Method$3 = 'get' | 'GET' | 'delete' | 'DELETE' | 'head' | 'HEAD' | 'options' | 'OPTIONS' | 'post' | 'POST' | 'put' | 'PUT' | 'patch' | 'PATCH' | 'purge' | 'PURGE' | 'link' | 'LINK' | 'unlink' | 'UNLINK';
+type AmbassadorRequestOptions$3<T = any> = {
+    _?: T;
+    url?: string;
+    method?: Method$3;
+    params?: any;
+    data?: any;
+    transformResponse?: ResponseTransformer$3 | ResponseTransformer$3[];
+};
+type AmbassadorFactory$3<Request, Response> = (payload: Request) => ((context: RequestContext$3) => AmbassadorRequestOptions$3<Response>) & {
+    __isAmbassador: boolean;
+};
+type AmbassadorFunctionDescriptor$3<Request = any, Response = any> = AmbassadorFactory$3<Request, Response>;
+type BuildAmbassadorFunction$3<T extends AmbassadorFunctionDescriptor$3> = T extends AmbassadorFunctionDescriptor$3<infer Request, infer Response> ? (req: Request) => Promise<Response> : never;
+
+declare global {
+	// eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
+	interface SymbolConstructor {
+		readonly observable: symbol;
+	}
+}
+
+declare const emptyObjectSymbol$3: unique symbol;
+
+/**
+Represents a strictly empty plain object, the `{}` value.
+
+When you annotate something as the type `{}`, it can be anything except `null` and `undefined`. This means that you cannot use `{}` to represent an empty plain object ([read more](https://stackoverflow.com/questions/47339869/typescript-empty-object-and-any-difference/52193484#52193484)).
+
+@example
+```
+import type {EmptyObject} from 'type-fest';
+
+// The following illustrates the problem with `{}`.
+const foo1: {} = {}; // Pass
+const foo2: {} = []; // Pass
+const foo3: {} = 42; // Pass
+const foo4: {} = {a: 1}; // Pass
+
+// With `EmptyObject` only the first case is valid.
+const bar1: EmptyObject = {}; // Pass
+const bar2: EmptyObject = 42; // Fail
+const bar3: EmptyObject = []; // Fail
+const bar4: EmptyObject = {a: 1}; // Fail
+```
+
+Unfortunately, `Record<string, never>`, `Record<keyof any, never>` and `Record<never, never>` do not work. See {@link https://github.com/sindresorhus/type-fest/issues/395 #395}.
+
+@category Object
+*/
+type EmptyObject$3 = {[emptyObjectSymbol$3]?: never};
+
+/**
+Returns a boolean for whether the two given types are equal.
+
+@link https://github.com/microsoft/TypeScript/issues/27024#issuecomment-421529650
+@link https://stackoverflow.com/questions/68961864/how-does-the-equals-work-in-typescript/68963796#68963796
+
+Use-cases:
+- If you want to make a conditional branch based on the result of a comparison of two types.
+
+@example
+```
+import type {IsEqual} from 'type-fest';
+
+// This type returns a boolean for whether the given array includes the given item.
+// `IsEqual` is used to compare the given array at position 0 and the given item and then return true if they are equal.
+type Includes<Value extends readonly any[], Item> =
+	Value extends readonly [Value[0], ...infer rest]
+		? IsEqual<Value[0], Item> extends true
+			? true
+			: Includes<rest, Item>
+		: false;
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsEqual$3<A, B> =
+	(<G>() => G extends A ? 1 : 2) extends
+	(<G>() => G extends B ? 1 : 2)
+		? true
+		: false;
+
+/**
+Filter out keys from an object.
+
+Returns `never` if `Exclude` is strictly equal to `Key`.
+Returns `never` if `Key` extends `Exclude`.
+Returns `Key` otherwise.
+
+@example
+```
+type Filtered = Filter<'foo', 'foo'>;
+//=> never
+```
+
+@example
+```
+type Filtered = Filter<'bar', string>;
+//=> never
+```
+
+@example
+```
+type Filtered = Filter<'bar', 'foo'>;
+//=> 'bar'
+```
+
+@see {Except}
+*/
+type Filter$3<KeyType, ExcludeType> = IsEqual$3<KeyType, ExcludeType> extends true ? never : (KeyType extends ExcludeType ? never : KeyType);
+
+type ExceptOptions$3 = {
+	/**
+	Disallow assigning non-specified properties.
+
+	Note that any omitted properties in the resulting type will be present in autocomplete as `undefined`.
+
+	@default false
+	*/
+	requireExactProps?: boolean;
+};
+
+/**
+Create a type from an object type without certain keys.
+
+We recommend setting the `requireExactProps` option to `true`.
+
+This type is a stricter version of [`Omit`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-5.html#the-omit-helper-type). The `Omit` type does not restrict the omitted keys to be keys present on the given type, while `Except` does. The benefits of a stricter type are avoiding typos and allowing the compiler to pick up on rename refactors automatically.
+
+This type was proposed to the TypeScript team, which declined it, saying they prefer that libraries implement stricter versions of the built-in types ([microsoft/TypeScript#30825](https://github.com/microsoft/TypeScript/issues/30825#issuecomment-523668235)).
+
+@example
+```
+import type {Except} from 'type-fest';
+
+type Foo = {
+	a: number;
+	b: string;
+};
+
+type FooWithoutA = Except<Foo, 'a'>;
+//=> {b: string}
+
+const fooWithoutA: FooWithoutA = {a: 1, b: '2'};
+//=> errors: 'a' does not exist in type '{ b: string; }'
+
+type FooWithoutB = Except<Foo, 'b', {requireExactProps: true}>;
+//=> {a: number} & Partial<Record<"b", never>>
+
+const fooWithoutB: FooWithoutB = {a: 1, b: '2'};
+//=> errors at 'b': Type 'string' is not assignable to type 'undefined'.
+```
+
+@category Object
+*/
+type Except$3<ObjectType, KeysType extends keyof ObjectType, Options extends ExceptOptions$3 = {requireExactProps: false}> = {
+	[KeyType in keyof ObjectType as Filter$3<KeyType, KeysType>]: ObjectType[KeyType];
+} & (Options['requireExactProps'] extends true
+	? Partial<Record<KeysType, never>>
+	: {});
+
+/**
+Extract the keys from a type where the value type of the key extends the given `Condition`.
+
+Internally this is used for the `ConditionalPick` and `ConditionalExcept` types.
+
+@example
+```
+import type {ConditionalKeys} from 'type-fest';
+
+interface Example {
+	a: string;
+	b: string | number;
+	c?: string;
+	d: {};
 }
-declare function getImportStatus$1(httpClient: HttpClient): GetImportStatusSignature;
-interface GetImportStatusSignature {
-    /**
-     * Gets the status of the import process.
-     */
-    (): Promise<GetImportStatusResponse & GetImportStatusResponseNonNullableFields>;
+
+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> = NonNullable<
+// Wrap in `NonNullable` to strip away the `undefined` type from the produced union.
+{
+	// 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 since the condition passes.
+		? 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() {}
 }
-declare function getNotImportedPosts$1(httpClient: HttpClient): GetNotImportedPostsSignature;
-interface GetNotImportedPostsSignature {
-    /**
-     * Gets the posts that were not yet imported either because of an error or because import is still in progress.
-     */
-    (): Promise<GetNotImportedPostsResponse & GetNotImportedPostsResponseNonNullableFields>;
+
+type ExceptPrimitivesFromAwesome = ConditionalExcept<Awesome, Primitive>;
+//=> {run: () => void}
+```
+
+@example
+```
+import type {ConditionalExcept} from 'type-fest';
+
+interface Example {
+	a: string;
+	b: string | number;
+	c: () => void;
+	d: {};
 }
 
-declare const startImport: BuildRESTFunction<typeof startImport$1> & typeof startImport$1;
-declare const submitUrlForImport: BuildRESTFunction<typeof submitUrlForImport$1> & typeof submitUrlForImport$1;
-declare const getImportStatus: BuildRESTFunction<typeof getImportStatus$1> & typeof getImportStatus$1;
-declare const getNotImportedPosts: BuildRESTFunction<typeof getNotImportedPosts$1> & typeof getNotImportedPosts$1;
+type NonStringKeysOnly = ConditionalExcept<Example, string>;
+//=> {b: string | number; c: () => void; d: {}}
+```
 
-type context$4_GetImportStatusRequest = GetImportStatusRequest;
-type context$4_GetImportStatusResponse = GetImportStatusResponse;
-type context$4_GetImportStatusResponseNonNullableFields = GetImportStatusResponseNonNullableFields;
-type context$4_GetNotImportedPostsRequest = GetNotImportedPostsRequest;
-type context$4_GetNotImportedPostsResponse = GetNotImportedPostsResponse;
-type context$4_GetNotImportedPostsResponseNonNullableFields = GetNotImportedPostsResponseNonNullableFields;
-type context$4_ImportStatus = ImportStatus;
-type context$4_StartImportRequest = StartImportRequest;
-type context$4_StartImportResponse = StartImportResponse;
-type context$4_SubmitUrlForImportRequest = SubmitUrlForImportRequest;
-type context$4_SubmitUrlForImportResponse = SubmitUrlForImportResponse;
-declare const context$4_getImportStatus: typeof getImportStatus;
-declare const context$4_getNotImportedPosts: typeof getNotImportedPosts;
-declare const context$4_startImport: typeof startImport;
-declare const context$4_submitUrlForImport: typeof submitUrlForImport;
-declare namespace context$4 {
-  export { type context$4_GetImportStatusRequest as GetImportStatusRequest, type context$4_GetImportStatusResponse as GetImportStatusResponse, type context$4_GetImportStatusResponseNonNullableFields as GetImportStatusResponseNonNullableFields, type context$4_GetNotImportedPostsRequest as GetNotImportedPostsRequest, type context$4_GetNotImportedPostsResponse as GetNotImportedPostsResponse, type context$4_GetNotImportedPostsResponseNonNullableFields as GetNotImportedPostsResponseNonNullableFields, type context$4_ImportStatus as ImportStatus, type Post$1 as Post, type context$4_StartImportRequest as StartImportRequest, type context$4_StartImportResponse as StartImportResponse, Status$2 as Status, type context$4_SubmitUrlForImportRequest as SubmitUrlForImportRequest, type context$4_SubmitUrlForImportResponse as SubmitUrlForImportResponse, context$4_getImportStatus as getImportStatus, context$4_getNotImportedPosts as getNotImportedPosts, context$4_startImport as startImport, context$4_submitUrlForImport as submitUrlForImport };
+@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$7<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$7<any> ? BuildEventDefinition$7<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;
 
 interface Category$2 {
     /** Category ID. */
@@ -1637,27 +2823,27 @@ interface CategoriesQueryBuilder {
     /** @param propertyName - Property whose value is compared with `value`.
      * @param value - Value to compare against.
      */
-    eq: (propertyName: '_id' | 'label' | 'postCount' | 'title' | 'rank' | 'displayPosition' | 'translationId' | 'language', value: any) => CategoriesQueryBuilder;
+    eq: (propertyName: '_id' | 'label' | 'postCount' | 'title' | 'displayPosition' | 'translationId' | 'language', value: any) => CategoriesQueryBuilder;
     /** @param propertyName - Property whose value is compared with `value`.
      * @param value - Value to compare against.
      */
-    ne: (propertyName: '_id' | 'label' | 'postCount' | 'title' | 'rank' | 'displayPosition' | 'translationId' | 'language', value: any) => CategoriesQueryBuilder;
+    ne: (propertyName: '_id' | 'label' | 'postCount' | 'title' | 'displayPosition' | 'translationId' | 'language', value: any) => CategoriesQueryBuilder;
     /** @param propertyName - Property whose value is compared with `value`.
      * @param value - Value to compare against.
      */
-    ge: (propertyName: 'postCount' | 'rank' | 'displayPosition', value: any) => CategoriesQueryBuilder;
+    ge: (propertyName: 'postCount' | 'displayPosition', value: any) => CategoriesQueryBuilder;
     /** @param propertyName - Property whose value is compared with `value`.
      * @param value - Value to compare against.
      */
-    gt: (propertyName: 'postCount' | 'rank' | 'displayPosition', value: any) => CategoriesQueryBuilder;
+    gt: (propertyName: 'postCount' | 'displayPosition', value: any) => CategoriesQueryBuilder;
     /** @param propertyName - Property whose value is compared with `value`.
      * @param value - Value to compare against.
      */
-    le: (propertyName: 'postCount' | 'rank' | 'displayPosition', value: any) => CategoriesQueryBuilder;
+    le: (propertyName: 'postCount' | 'displayPosition', value: any) => CategoriesQueryBuilder;
     /** @param propertyName - Property whose value is compared with `value`.
      * @param value - Value to compare against.
      */
-    lt: (propertyName: 'postCount' | 'rank' | 'displayPosition', value: any) => CategoriesQueryBuilder;
+    lt: (propertyName: 'postCount' | 'displayPosition', value: any) => CategoriesQueryBuilder;
     /** @param propertyName - Property whose value is compared with `string`.
      * @param string - String to compare against. Case-insensitive.
      */
@@ -1666,12 +2852,12 @@ interface CategoriesQueryBuilder {
      * @param values - List of values to compare against.
      */
     hasSome: (propertyName: '_id' | 'label' | 'title' | 'slug', value: any[]) => CategoriesQueryBuilder;
-    in: (propertyName: 'label' | 'postCount' | 'title' | 'rank' | 'displayPosition' | 'translationId' | 'language', value: any) => CategoriesQueryBuilder;
+    in: (propertyName: 'label' | 'postCount' | 'title' | 'displayPosition' | 'translationId' | 'language', value: any) => CategoriesQueryBuilder;
     exists: (propertyName: 'label' | 'title' | 'translationId' | 'language', value: boolean) => CategoriesQueryBuilder;
     /** @param propertyNames - Properties used in the sort. To sort by multiple properties, pass properties as additional arguments. */
-    ascending: (...propertyNames: Array<'label' | 'postCount' | 'title' | 'rank' | 'displayPosition' | 'language' | 'slug'>) => CategoriesQueryBuilder;
+    ascending: (...propertyNames: Array<'label' | 'postCount' | 'title' | 'displayPosition' | 'language' | 'slug'>) => CategoriesQueryBuilder;
     /** @param propertyNames - Properties used in the sort. To sort by multiple properties, pass properties as additional arguments. */
-    descending: (...propertyNames: Array<'label' | 'postCount' | 'title' | 'rank' | 'displayPosition' | 'language' | 'slug'>) => CategoriesQueryBuilder;
+    descending: (...propertyNames: Array<'label' | 'postCount' | 'title' | 'displayPosition' | 'language' | 'slug'>) => CategoriesQueryBuilder;
     /** @param limit - Number of items to return, which is also the `pageSize` of the results object. */
     limit: (limit: number) => CategoriesQueryBuilder;
     /** @param skip - Number of items to skip in the query results before returning the results. */
@@ -1679,7 +2865,7 @@ interface CategoriesQueryBuilder {
     find: () => Promise<CategoriesQueryResult>;
 }
 
-declare function getCategory$1(httpClient: HttpClient): GetCategorySignature;
+declare function getCategory$1(httpClient: HttpClient$3): GetCategorySignature;
 interface GetCategorySignature {
     /**
      * Gets a category by the specified ID.
@@ -1692,7 +2878,7 @@ interface GetCategorySignature {
      */
     (categoryId: string, options?: GetCategoryOptions | undefined): Promise<GetCategoryResponse & GetCategoryResponseNonNullableFields>;
 }
-declare function getCategoryBySlug$1(httpClient: HttpClient): GetCategoryBySlugSignature;
+declare function getCategoryBySlug$1(httpClient: HttpClient$3): GetCategoryBySlugSignature;
 interface GetCategoryBySlugSignature {
     /**
      * Gets a category by the specified slug.
@@ -1709,7 +2895,7 @@ interface GetCategoryBySlugSignature {
      */
     (slug: string, options?: GetCategoryBySlugOptions | undefined): Promise<GetCategoryBySlugResponse & GetCategoryBySlugResponseNonNullableFields>;
 }
-declare function listCategories$1(httpClient: HttpClient): ListCategoriesSignature;
+declare function listCategories$1(httpClient: HttpClient$3): ListCategoriesSignature;
 interface ListCategoriesSignature {
     /**
      * Retrieves a list of categories.
@@ -1720,7 +2906,7 @@ interface ListCategoriesSignature {
      */
     (options?: ListCategoriesOptions | undefined): Promise<ListCategoriesResponse & ListCategoriesResponseNonNullableFields>;
 }
-declare function queryCategories$1(httpClient: HttpClient): QueryCategoriesSignature;
+declare function queryCategories$1(httpClient: HttpClient$3): QueryCategoriesSignature;
 interface QueryCategoriesSignature {
     /**
      * Creates a query to retrieve a list of categories.
@@ -1741,16 +2927,34 @@ interface QueryCategoriesSignature {
      */
     (options?: QueryCategoriesOptions | undefined): CategoriesQueryBuilder;
 }
-declare const onCategoryCreated$1: EventDefinition<CategoryCreatedEnvelope, "wix.blog.v3.category_created">;
-declare const onCategoryUpdated$1: EventDefinition<CategoryUpdatedEnvelope, "wix.blog.v3.category_updated">;
-declare const onCategoryDeleted$1: EventDefinition<CategoryDeletedEnvelope, "wix.blog.v3.category_deleted">;
+declare const onCategoryCreated$1: EventDefinition$7<CategoryCreatedEnvelope, "wix.blog.v3.category_created">;
+declare const onCategoryUpdated$1: EventDefinition$7<CategoryUpdatedEnvelope, "wix.blog.v3.category_updated">;
+declare const onCategoryDeleted$1: EventDefinition$7<CategoryDeletedEnvelope, "wix.blog.v3.category_deleted">;
+
+type EventDefinition$6<Payload = unknown, Type extends string = string> = {
+    __type: 'event-definition';
+    type: Type;
+    isDomainEvent?: boolean;
+    transformations?: (envelope: unknown) => Payload;
+    __payload: Payload;
+};
+declare function EventDefinition$6<Type extends string>(type: Type, isDomainEvent?: boolean, transformations?: (envelope: any) => unknown): <Payload = unknown>() => EventDefinition$6<Payload, Type>;
+type EventHandler$6<T extends EventDefinition$6> = (payload: T['__payload']) => void | Promise<void>;
+type BuildEventDefinition$6<T extends EventDefinition$6<any, string>> = (handler: EventHandler$6<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;
+	}
+}
 
-declare function createEventModule$3<T extends EventDefinition<any, string>>(eventDefinition: T): BuildEventDefinition<T> & T;
+declare function createEventModule$3<T extends EventDefinition$6<any, string>>(eventDefinition: T): BuildEventDefinition$6<T> & T;
 
-declare const getCategory: BuildRESTFunction<typeof getCategory$1> & typeof getCategory$1;
-declare const getCategoryBySlug: BuildRESTFunction<typeof getCategoryBySlug$1> & typeof getCategoryBySlug$1;
-declare const listCategories: BuildRESTFunction<typeof listCategories$1> & typeof listCategories$1;
-declare const queryCategories: BuildRESTFunction<typeof queryCategories$1> & typeof queryCategories$1;
+declare const getCategory: MaybeContext$3<BuildRESTFunction$3<typeof getCategory$1> & typeof getCategory$1>;
+declare const getCategoryBySlug: MaybeContext$3<BuildRESTFunction$3<typeof getCategoryBySlug$1> & typeof getCategoryBySlug$1>;
+declare const listCategories: MaybeContext$3<BuildRESTFunction$3<typeof listCategories$1> & typeof listCategories$1>;
+declare const queryCategories: MaybeContext$3<BuildRESTFunction$3<typeof queryCategories$1> & typeof queryCategories$1>;
 
 type _publicOnCategoryCreatedType = typeof onCategoryCreated$1;
 /**
@@ -1823,6 +3027,416 @@ declare namespace context$3 {
   export { type ActionEvent$3 as ActionEvent, type ApplicationError$2 as ApplicationError, type BaseEventMetadata$3 as BaseEventMetadata, type BlogPaging$2 as BlogPaging, type BulkActionMetadata$2 as BulkActionMetadata, type context$3_BulkCategoryResult as BulkCategoryResult, type context$3_BulkCreateCategoriesRequest as BulkCreateCategoriesRequest, type context$3_BulkCreateCategoriesResponse as BulkCreateCategoriesResponse, type context$3_BulkDeleteCategoryRequest as BulkDeleteCategoryRequest, type context$3_BulkDeleteCategoryResponse as BulkDeleteCategoryResponse, type context$3_BulkUpdateCategoriesRequest as BulkUpdateCategoriesRequest, type context$3_BulkUpdateCategoriesResponse as BulkUpdateCategoriesResponse, type context$3_CategoriesQueryBuilder as CategoriesQueryBuilder, type context$3_CategoriesQueryResult as CategoriesQueryResult, type Category$2 as Category, type context$3_CategoryCreatedEnvelope as CategoryCreatedEnvelope, type context$3_CategoryDeletedEnvelope as CategoryDeletedEnvelope, type context$3_CategoryLanguageCount as CategoryLanguageCount, type CategoryTranslation$2 as CategoryTranslation, type context$3_CategoryUpdatedEnvelope as CategoryUpdatedEnvelope, type context$3_CreateCategoryRequest as CreateCategoryRequest, type context$3_CreateCategoryResponse as CreateCategoryResponse, type CursorPaging$3 as CursorPaging, type Cursors$3 as Cursors, type context$3_DeleteCategoryRequest as DeleteCategoryRequest, type context$3_DeleteCategoryResponse as DeleteCategoryResponse, type DomainEvent$3 as DomainEvent, type DomainEventBodyOneOf$3 as DomainEventBodyOneOf, type EntityCreatedEvent$3 as EntityCreatedEvent, type EntityDeletedEvent$3 as EntityDeletedEvent, type EntityUpdatedEvent$3 as EntityUpdatedEvent, type EventMetadata$3 as EventMetadata, Field$3 as Field, type context$3_GetCategoriesCountByLanguageRequest as GetCategoriesCountByLanguageRequest, type context$3_GetCategoriesCountByLanguageResponse as GetCategoriesCountByLanguageResponse, type context$3_GetCategoryBySlugOptions as GetCategoryBySlugOptions, type context$3_GetCategoryBySlugRequest as GetCategoryBySlugRequest, type context$3_GetCategoryBySlugResponse as GetCategoryBySlugResponse, type context$3_GetCategoryBySlugResponseNonNullableFields as GetCategoryBySlugResponseNonNullableFields, type context$3_GetCategoryOptions as GetCategoryOptions, type context$3_GetCategoryRequest as GetCategoryRequest, type context$3_GetCategoryResponse as GetCategoryResponse, type context$3_GetCategoryResponseNonNullableFields as GetCategoryResponseNonNullableFields, type IdentificationData$3 as IdentificationData, type IdentificationDataIdOneOf$3 as IdentificationDataIdOneOf, type context$3_InitialCategoriesCopied as InitialCategoriesCopied, type ItemMetadata$2 as ItemMetadata, type Keyword$3 as Keyword, type context$3_ListCategoriesOptions as ListCategoriesOptions, type context$3_ListCategoriesRequest as ListCategoriesRequest, type context$3_ListCategoriesResponse as ListCategoriesResponse, type context$3_ListCategoriesResponseNonNullableFields as ListCategoriesResponseNonNullableFields, type context$3_MaskedCategory as MaskedCategory, type MessageEnvelope$3 as MessageEnvelope, type MetaData$3 as MetaData, type Paging$3 as Paging, type PagingMetadataV2$3 as PagingMetadataV2, type PlatformQuery$3 as PlatformQuery, type PlatformQueryPagingMethodOneOf$3 as PlatformQueryPagingMethodOneOf, type context$3_QueryCategoriesOptions as QueryCategoriesOptions, type context$3_QueryCategoriesRequest as QueryCategoriesRequest, type context$3_QueryCategoriesResponse as QueryCategoriesResponse, type context$3_QueryCategoriesResponseNonNullableFields as QueryCategoriesResponseNonNullableFields, type RestoreInfo$3 as RestoreInfo, type SeoSchema$3 as SeoSchema, type Settings$3 as Settings, SortOrder$3 as SortOrder, type Sorting$3 as Sorting, type Tag$3 as Tag, type context$3_UpdateCategoryRequest as UpdateCategoryRequest, type context$3_UpdateCategoryResponse as UpdateCategoryResponse, WebhookIdentityType$3 as WebhookIdentityType, type context$3__publicOnCategoryCreatedType as _publicOnCategoryCreatedType, type context$3__publicOnCategoryDeletedType as _publicOnCategoryDeletedType, type context$3__publicOnCategoryUpdatedType as _publicOnCategoryUpdatedType, context$3_getCategory as getCategory, context$3_getCategoryBySlug as getCategoryBySlug, context$3_listCategories as listCategories, context$3_onCategoryCreated as onCategoryCreated, context$3_onCategoryDeleted as onCategoryDeleted, context$3_onCategoryUpdated as onCategoryUpdated, onCategoryCreated$1 as publicOnCategoryCreated, onCategoryDeleted$1 as publicOnCategoryDeleted, onCategoryUpdated$1 as publicOnCategoryUpdated, context$3_queryCategories as queryCategories };
 }
 
+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 bast url to use for API requests, for example `www.wixapis.com`
+     */
+    apiBaseUrl?: string;
+    /**
+     * Possible data to be provided by every host, for cross cutting concerns
+     * like internationalization, billing, etc.
+     */
+    essentials?: {
+        /**
+         * The language of the currently viewed session
+         */
+        language?: string;
+        /**
+         * The locale of the currently viewed session
+         */
+        locale?: string;
+        /**
+         * Any headers that should be passed through to the API requests
+         */
+        passThroughHeaders?: Record<string, string>;
+    };
+};
+
+type RESTFunctionDescriptor$2<T extends (...args: any[]) => any = (...args: any[]) => any> = (httpClient: HttpClient$2) => T;
+interface HttpClient$2 {
+    request<TResponse, TData = any>(req: RequestOptionsFactory$2<TResponse, TData>): Promise<HttpResponse$2<TResponse>>;
+    fetchWithAuth: typeof fetch;
+    wixAPIFetch: (relativeUrl: string, options: RequestInit) => Promise<Response>;
+    getActiveToken?: () => string | undefined;
+}
+type RequestOptionsFactory$2<TResponse = any, TData = any> = (context: any) => RequestOptions$2<TResponse, TData>;
+type HttpResponse$2<T = any> = {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: any;
+    request?: any;
+};
+type RequestOptions$2<_TResponse = any, Data = any> = {
+    method: 'POST' | 'GET' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+    url: string;
+    data?: Data;
+    params?: URLSearchParams;
+} & APIMetadata$2;
+type APIMetadata$2 = {
+    methodFqn?: string;
+    entityFqdn?: string;
+    packageName?: string;
+};
+type BuildRESTFunction$2<T extends RESTFunctionDescriptor$2> = T extends RESTFunctionDescriptor$2<infer U> ? U : never;
+type EventDefinition$5<Payload = unknown, Type extends string = string> = {
+    __type: 'event-definition';
+    type: Type;
+    isDomainEvent?: boolean;
+    transformations?: (envelope: unknown) => Payload;
+    __payload: Payload;
+};
+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$2 = {
+    request: any;
+    metadata: any;
+};
+type ServicePluginContract$2 = Record<string, (payload: ServicePluginMethodInput$2) => unknown | Promise<unknown>>;
+type ServicePluginMethodMetadata$2 = {
+    name: string;
+    primaryHttpMappingPath: string;
+    transformations: {
+        fromREST: (...args: unknown[]) => ServicePluginMethodInput$2;
+        toREST: (...args: unknown[]) => unknown;
+    };
+};
+type ServicePluginDefinition$2<Contract extends ServicePluginContract$2> = {
+    __type: 'service-plugin-definition';
+    componentType: string;
+    methods: ServicePluginMethodMetadata$2[];
+    __contract: Contract;
+};
+declare function ServicePluginDefinition$2<Contract extends ServicePluginContract$2>(componentType: string, methods: ServicePluginMethodMetadata$2[]): ServicePluginDefinition$2<Contract>;
+type BuildServicePluginDefinition$2<T extends ServicePluginDefinition$2<any>> = (implementation: T['__contract']) => void;
+declare const SERVICE_PLUGIN_ERROR_TYPE$2 = "wix_spi_error";
+
+type RequestContext$2 = {
+    isSSR: boolean;
+    host: string;
+    protocol?: string;
+};
+type ResponseTransformer$2 = (data: any, headers?: any) => any;
+/**
+ * Ambassador request options types are copied mostly from AxiosRequestConfig.
+ * They are copied and not imported to reduce the amount of dependencies (to reduce install time).
+ * https://github.com/axios/axios/blob/3f53eb6960f05a1f88409c4b731a40de595cb825/index.d.ts#L307-L315
+ */
+type Method$2 = 'get' | 'GET' | 'delete' | 'DELETE' | 'head' | 'HEAD' | 'options' | 'OPTIONS' | 'post' | 'POST' | 'put' | 'PUT' | 'patch' | 'PATCH' | 'purge' | 'PURGE' | 'link' | 'LINK' | 'unlink' | 'UNLINK';
+type AmbassadorRequestOptions$2<T = any> = {
+    _?: T;
+    url?: string;
+    method?: Method$2;
+    params?: any;
+    data?: any;
+    transformResponse?: ResponseTransformer$2 | ResponseTransformer$2[];
+};
+type AmbassadorFactory$2<Request, Response> = (payload: Request) => ((context: RequestContext$2) => AmbassadorRequestOptions$2<Response>) & {
+    __isAmbassador: boolean;
+};
+type AmbassadorFunctionDescriptor$2<Request = any, Response = any> = AmbassadorFactory$2<Request, Response>;
+type BuildAmbassadorFunction$2<T extends AmbassadorFunctionDescriptor$2> = T extends AmbassadorFunctionDescriptor$2<infer Request, infer Response> ? (req: Request) => Promise<Response> : never;
+
+declare global {
+	// eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
+	interface SymbolConstructor {
+		readonly observable: symbol;
+	}
+}
+
+declare const emptyObjectSymbol$2: unique symbol;
+
+/**
+Represents a strictly empty plain object, the `{}` value.
+
+When you annotate something as the type `{}`, it can be anything except `null` and `undefined`. This means that you cannot use `{}` to represent an empty plain object ([read more](https://stackoverflow.com/questions/47339869/typescript-empty-object-and-any-difference/52193484#52193484)).
+
+@example
+```
+import type {EmptyObject} from 'type-fest';
+
+// The following illustrates the problem with `{}`.
+const foo1: {} = {}; // Pass
+const foo2: {} = []; // Pass
+const foo3: {} = 42; // Pass
+const foo4: {} = {a: 1}; // Pass
+
+// With `EmptyObject` only the first case is valid.
+const bar1: EmptyObject = {}; // Pass
+const bar2: EmptyObject = 42; // Fail
+const bar3: EmptyObject = []; // Fail
+const bar4: EmptyObject = {a: 1}; // Fail
+```
+
+Unfortunately, `Record<string, never>`, `Record<keyof any, never>` and `Record<never, never>` do not work. See {@link https://github.com/sindresorhus/type-fest/issues/395 #395}.
+
+@category Object
+*/
+type EmptyObject$2 = {[emptyObjectSymbol$2]?: never};
+
+/**
+Returns a boolean for whether the two given types are equal.
+
+@link https://github.com/microsoft/TypeScript/issues/27024#issuecomment-421529650
+@link https://stackoverflow.com/questions/68961864/how-does-the-equals-work-in-typescript/68963796#68963796
+
+Use-cases:
+- If you want to make a conditional branch based on the result of a comparison of two types.
+
+@example
+```
+import type {IsEqual} from 'type-fest';
+
+// This type returns a boolean for whether the given array includes the given item.
+// `IsEqual` is used to compare the given array at position 0 and the given item and then return true if they are equal.
+type Includes<Value extends readonly any[], Item> =
+	Value extends readonly [Value[0], ...infer rest]
+		? IsEqual<Value[0], Item> extends true
+			? true
+			: Includes<rest, Item>
+		: false;
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsEqual$2<A, B> =
+	(<G>() => G extends A ? 1 : 2) extends
+	(<G>() => G extends B ? 1 : 2)
+		? true
+		: false;
+
+/**
+Filter out keys from an object.
+
+Returns `never` if `Exclude` is strictly equal to `Key`.
+Returns `never` if `Key` extends `Exclude`.
+Returns `Key` otherwise.
+
+@example
+```
+type Filtered = Filter<'foo', 'foo'>;
+//=> never
+```
+
+@example
+```
+type Filtered = Filter<'bar', string>;
+//=> never
+```
+
+@example
+```
+type Filtered = Filter<'bar', 'foo'>;
+//=> 'bar'
+```
+
+@see {Except}
+*/
+type Filter$2<KeyType, ExcludeType> = IsEqual$2<KeyType, ExcludeType> extends true ? never : (KeyType extends ExcludeType ? never : KeyType);
+
+type ExceptOptions$2 = {
+	/**
+	Disallow assigning non-specified properties.
+
+	Note that any omitted properties in the resulting type will be present in autocomplete as `undefined`.
+
+	@default false
+	*/
+	requireExactProps?: boolean;
+};
+
+/**
+Create a type from an object type without certain keys.
+
+We recommend setting the `requireExactProps` option to `true`.
+
+This type is a stricter version of [`Omit`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-5.html#the-omit-helper-type). The `Omit` type does not restrict the omitted keys to be keys present on the given type, while `Except` does. The benefits of a stricter type are avoiding typos and allowing the compiler to pick up on rename refactors automatically.
+
+This type was proposed to the TypeScript team, which declined it, saying they prefer that libraries implement stricter versions of the built-in types ([microsoft/TypeScript#30825](https://github.com/microsoft/TypeScript/issues/30825#issuecomment-523668235)).
+
+@example
+```
+import type {Except} from 'type-fest';
+
+type Foo = {
+	a: number;
+	b: string;
+};
+
+type FooWithoutA = Except<Foo, 'a'>;
+//=> {b: string}
+
+const fooWithoutA: FooWithoutA = {a: 1, b: '2'};
+//=> errors: 'a' does not exist in type '{ b: string; }'
+
+type FooWithoutB = Except<Foo, 'b', {requireExactProps: true}>;
+//=> {a: number} & Partial<Record<"b", never>>
+
+const fooWithoutB: FooWithoutB = {a: 1, b: '2'};
+//=> errors at 'b': Type 'string' is not assignable to type 'undefined'.
+```
+
+@category Object
+*/
+type Except$2<ObjectType, KeysType extends keyof ObjectType, Options extends ExceptOptions$2 = {requireExactProps: false}> = {
+	[KeyType in keyof ObjectType as Filter$2<KeyType, KeysType>]: ObjectType[KeyType];
+} & (Options['requireExactProps'] extends true
+	? Partial<Record<KeysType, never>>
+	: {});
+
+/**
+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> = NonNullable<
+// Wrap in `NonNullable` to strip away the `undefined` type from the produced union.
+{
+	// 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 since the condition passes.
+		? 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$5<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$5<any> ? BuildEventDefinition$5<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;
+
 interface DraftPost$1 {
     /**
      * Draft post ID.
@@ -5140,7 +6754,7 @@ interface DraftPostsQueryBuilder {
     find: () => Promise<DraftPostsQueryResult>;
 }
 
-declare function createDraftPost$1(httpClient: HttpClient): CreateDraftPostSignature;
+declare function createDraftPost$1(httpClient: HttpClient$2): CreateDraftPostSignature;
 interface CreateDraftPostSignature {
     /**
      * Creates a draft post.
@@ -5151,7 +6765,7 @@ interface CreateDraftPostSignature {
      */
     (draftPost: DraftPost$1, options?: CreateDraftPostOptions | undefined): Promise<CreateDraftPostResponse & CreateDraftPostResponseNonNullableFields>;
 }
-declare function bulkCreateDraftPosts$1(httpClient: HttpClient): BulkCreateDraftPostsSignature;
+declare function bulkCreateDraftPosts$1(httpClient: HttpClient$2): BulkCreateDraftPostsSignature;
 interface BulkCreateDraftPostsSignature {
     /**
      * Creates multiple draft posts.
@@ -5160,7 +6774,7 @@ interface BulkCreateDraftPostsSignature {
      */
     (draftPosts: DraftPost$1[], options?: BulkCreateDraftPostsOptions | undefined): Promise<BulkCreateDraftPostsResponse & BulkCreateDraftPostsResponseNonNullableFields>;
 }
-declare function bulkUpdateDraftPosts$1(httpClient: HttpClient): BulkUpdateDraftPostsSignature;
+declare function bulkUpdateDraftPosts$1(httpClient: HttpClient$2): BulkUpdateDraftPostsSignature;
 interface BulkUpdateDraftPostsSignature {
     /**
      * Updates multiple draft posts.
@@ -5168,7 +6782,7 @@ interface BulkUpdateDraftPostsSignature {
      */
     (options?: BulkUpdateDraftPostsOptions | undefined): Promise<BulkUpdateDraftPostsResponse & BulkUpdateDraftPostsResponseNonNullableFields>;
 }
-declare function listDeletedDraftPosts$1(httpClient: HttpClient): ListDeletedDraftPostsSignature;
+declare function listDeletedDraftPosts$1(httpClient: HttpClient$2): ListDeletedDraftPostsSignature;
 interface ListDeletedDraftPostsSignature {
     /**
      * Retrieves a list of up to 100 deleted draft posts.
@@ -5181,7 +6795,7 @@ interface ListDeletedDraftPostsSignature {
      */
     (options?: ListDeletedDraftPostsOptions | undefined): Promise<ListDeletedDraftPostsResponse & ListDeletedDraftPostsResponseNonNullableFields>;
 }
-declare function getDraftPost$1(httpClient: HttpClient): GetDraftPostSignature;
+declare function getDraftPost$1(httpClient: HttpClient$2): GetDraftPostSignature;
 interface GetDraftPostSignature {
     /**
      * Gets a draft post by the provided ID.
@@ -5192,7 +6806,7 @@ interface GetDraftPostSignature {
      */
     (draftPostId: string, options?: GetDraftPostOptions | undefined): Promise<GetDraftPostResponse & GetDraftPostResponseNonNullableFields>;
 }
-declare function updateDraftPost$1(httpClient: HttpClient): UpdateDraftPostSignature;
+declare function updateDraftPost$1(httpClient: HttpClient$2): UpdateDraftPostSignature;
 interface UpdateDraftPostSignature {
     /**
      * Updates a draft post.
@@ -5202,7 +6816,7 @@ interface UpdateDraftPostSignature {
      */
     (_id: string, draftPost: UpdateDraftPost, options?: UpdateDraftPostOptions | undefined): Promise<UpdateDraftPostResponse & UpdateDraftPostResponseNonNullableFields>;
 }
-declare function deleteDraftPost$1(httpClient: HttpClient): DeleteDraftPostSignature;
+declare function deleteDraftPost$1(httpClient: HttpClient$2): DeleteDraftPostSignature;
 interface DeleteDraftPostSignature {
     /**
      * Moves a draft post with the provided ID to the trash bin.
@@ -5214,7 +6828,7 @@ interface DeleteDraftPostSignature {
      */
     (draftPostId: string, options?: DeleteDraftPostOptions | undefined): Promise<void>;
 }
-declare function removeFromTrashBin$1(httpClient: HttpClient): RemoveFromTrashBinSignature;
+declare function removeFromTrashBin$1(httpClient: HttpClient$2): RemoveFromTrashBinSignature;
 interface RemoveFromTrashBinSignature {
     /**
      * Permanently deletes a draft post by the provided ID from the trash bin.
@@ -5224,7 +6838,7 @@ interface RemoveFromTrashBinSignature {
      */
     (draftPostId: string): Promise<void>;
 }
-declare function bulkDeleteDraftPosts$1(httpClient: HttpClient): BulkDeleteDraftPostsSignature;
+declare function bulkDeleteDraftPosts$1(httpClient: HttpClient$2): BulkDeleteDraftPostsSignature;
 interface BulkDeleteDraftPostsSignature {
     /**
      * Deletes multiple draft posts.
@@ -5233,7 +6847,7 @@ interface BulkDeleteDraftPostsSignature {
      */
     (postIds: string[], options?: BulkDeleteDraftPostsOptions | undefined): Promise<BulkDeleteDraftPostsResponse & BulkDeleteDraftPostsResponseNonNullableFields>;
 }
-declare function listDraftPosts$1(httpClient: HttpClient): ListDraftPostsSignature;
+declare function listDraftPosts$1(httpClient: HttpClient$2): ListDraftPostsSignature;
 interface ListDraftPostsSignature {
     /**
      * Retrieves a list of up to 100 draft posts per request.
@@ -5246,7 +6860,7 @@ interface ListDraftPostsSignature {
      */
     (options?: ListDraftPostsOptions | undefined): Promise<ListDraftPostsResponse & ListDraftPostsResponseNonNullableFields>;
 }
-declare function getDeletedDraftPost$1(httpClient: HttpClient): GetDeletedDraftPostSignature;
+declare function getDeletedDraftPost$1(httpClient: HttpClient$2): GetDeletedDraftPostSignature;
 interface GetDeletedDraftPostSignature {
     /**
      * Gets a deleted draft post from the trash bin by the provided ID.
@@ -5256,7 +6870,7 @@ interface GetDeletedDraftPostSignature {
      */
     (draftPostId: string): Promise<GetDeletedDraftPostResponse & GetDeletedDraftPostResponseNonNullableFields>;
 }
-declare function restoreFromTrashBin$1(httpClient: HttpClient): RestoreFromTrashBinSignature;
+declare function restoreFromTrashBin$1(httpClient: HttpClient$2): RestoreFromTrashBinSignature;
 interface RestoreFromTrashBinSignature {
     /**
      * Restores a deleted draft post from the trash bin by the provided ID.
@@ -5266,7 +6880,7 @@ interface RestoreFromTrashBinSignature {
      */
     (draftPostId: string): Promise<RestoreFromTrashBinResponse & RestoreFromTrashBinResponseNonNullableFields>;
 }
-declare function queryDraftPosts$1(httpClient: HttpClient): QueryDraftPostsSignature;
+declare function queryDraftPosts$1(httpClient: HttpClient$2): QueryDraftPostsSignature;
 interface QueryDraftPostsSignature {
     /**
      * Retrieves a list of up to 100 draft posts, given the provided paging, filtering, and sorting.
@@ -5279,7 +6893,7 @@ interface QueryDraftPostsSignature {
      */
     (options?: QueryDraftPostsOptions | undefined): DraftPostsQueryBuilder;
 }
-declare function publishDraftPost$1(httpClient: HttpClient): PublishDraftPostSignature;
+declare function publishDraftPost$1(httpClient: HttpClient$2): PublishDraftPostSignature;
 interface PublishDraftPostSignature {
     /**
      * Publishes a specified draft post by ID. This creates a new post entity with the data from the draft post.
@@ -5289,26 +6903,44 @@ interface PublishDraftPostSignature {
      */
     (draftPostId: string): Promise<PublishDraftPostResponse & PublishDraftPostResponseNonNullableFields>;
 }
-declare const onDraftCreated$1: EventDefinition<DraftCreatedEnvelope, "wix.blog.v3.draft_created">;
-declare const onDraftUpdated$1: EventDefinition<DraftUpdatedEnvelope, "wix.blog.v3.draft_updated">;
-declare const onDraftDeleted$1: EventDefinition<DraftDeletedEnvelope, "wix.blog.v3.draft_deleted">;
-
-declare function createEventModule$2<T extends EventDefinition<any, string>>(eventDefinition: T): BuildEventDefinition<T> & T;
-
-declare const createDraftPost: BuildRESTFunction<typeof createDraftPost$1> & typeof createDraftPost$1;
-declare const bulkCreateDraftPosts: BuildRESTFunction<typeof bulkCreateDraftPosts$1> & typeof bulkCreateDraftPosts$1;
-declare const bulkUpdateDraftPosts: BuildRESTFunction<typeof bulkUpdateDraftPosts$1> & typeof bulkUpdateDraftPosts$1;
-declare const listDeletedDraftPosts: BuildRESTFunction<typeof listDeletedDraftPosts$1> & typeof listDeletedDraftPosts$1;
-declare const getDraftPost: BuildRESTFunction<typeof getDraftPost$1> & typeof getDraftPost$1;
-declare const updateDraftPost: BuildRESTFunction<typeof updateDraftPost$1> & typeof updateDraftPost$1;
-declare const deleteDraftPost: BuildRESTFunction<typeof deleteDraftPost$1> & typeof deleteDraftPost$1;
-declare const removeFromTrashBin: BuildRESTFunction<typeof removeFromTrashBin$1> & typeof removeFromTrashBin$1;
-declare const bulkDeleteDraftPosts: BuildRESTFunction<typeof bulkDeleteDraftPosts$1> & typeof bulkDeleteDraftPosts$1;
-declare const listDraftPosts: BuildRESTFunction<typeof listDraftPosts$1> & typeof listDraftPosts$1;
-declare const getDeletedDraftPost: BuildRESTFunction<typeof getDeletedDraftPost$1> & typeof getDeletedDraftPost$1;
-declare const restoreFromTrashBin: BuildRESTFunction<typeof restoreFromTrashBin$1> & typeof restoreFromTrashBin$1;
-declare const queryDraftPosts: BuildRESTFunction<typeof queryDraftPosts$1> & typeof queryDraftPosts$1;
-declare const publishDraftPost: BuildRESTFunction<typeof publishDraftPost$1> & typeof publishDraftPost$1;
+declare const onDraftCreated$1: EventDefinition$5<DraftCreatedEnvelope, "wix.blog.v3.draft_created">;
+declare const onDraftUpdated$1: EventDefinition$5<DraftUpdatedEnvelope, "wix.blog.v3.draft_updated">;
+declare const onDraftDeleted$1: EventDefinition$5<DraftDeletedEnvelope, "wix.blog.v3.draft_deleted">;
+
+type EventDefinition$4<Payload = unknown, Type extends string = string> = {
+    __type: 'event-definition';
+    type: Type;
+    isDomainEvent?: boolean;
+    transformations?: (envelope: unknown) => Payload;
+    __payload: Payload;
+};
+declare function EventDefinition$4<Type extends string>(type: Type, isDomainEvent?: boolean, transformations?: (envelope: any) => unknown): <Payload = unknown>() => EventDefinition$4<Payload, Type>;
+type EventHandler$4<T extends EventDefinition$4> = (payload: T['__payload']) => void | Promise<void>;
+type BuildEventDefinition$4<T extends EventDefinition$4<any, string>> = (handler: EventHandler$4<T>) => void;
+
+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 function createEventModule$2<T extends EventDefinition$4<any, string>>(eventDefinition: T): BuildEventDefinition$4<T> & T;
+
+declare const createDraftPost: MaybeContext$2<BuildRESTFunction$2<typeof createDraftPost$1> & typeof createDraftPost$1>;
+declare const bulkCreateDraftPosts: MaybeContext$2<BuildRESTFunction$2<typeof bulkCreateDraftPosts$1> & typeof bulkCreateDraftPosts$1>;
+declare const bulkUpdateDraftPosts: MaybeContext$2<BuildRESTFunction$2<typeof bulkUpdateDraftPosts$1> & typeof bulkUpdateDraftPosts$1>;
+declare const listDeletedDraftPosts: MaybeContext$2<BuildRESTFunction$2<typeof listDeletedDraftPosts$1> & typeof listDeletedDraftPosts$1>;
+declare const getDraftPost: MaybeContext$2<BuildRESTFunction$2<typeof getDraftPost$1> & typeof getDraftPost$1>;
+declare const updateDraftPost: MaybeContext$2<BuildRESTFunction$2<typeof updateDraftPost$1> & typeof updateDraftPost$1>;
+declare const deleteDraftPost: MaybeContext$2<BuildRESTFunction$2<typeof deleteDraftPost$1> & typeof deleteDraftPost$1>;
+declare const removeFromTrashBin: MaybeContext$2<BuildRESTFunction$2<typeof removeFromTrashBin$1> & typeof removeFromTrashBin$1>;
+declare const bulkDeleteDraftPosts: MaybeContext$2<BuildRESTFunction$2<typeof bulkDeleteDraftPosts$1> & typeof bulkDeleteDraftPosts$1>;
+declare const listDraftPosts: MaybeContext$2<BuildRESTFunction$2<typeof listDraftPosts$1> & typeof listDraftPosts$1>;
+declare const getDeletedDraftPost: MaybeContext$2<BuildRESTFunction$2<typeof getDeletedDraftPost$1> & typeof getDeletedDraftPost$1>;
+declare const restoreFromTrashBin: MaybeContext$2<BuildRESTFunction$2<typeof restoreFromTrashBin$1> & typeof restoreFromTrashBin$1>;
+declare const queryDraftPosts: MaybeContext$2<BuildRESTFunction$2<typeof queryDraftPosts$1> & typeof queryDraftPosts$1>;
+declare const publishDraftPost: MaybeContext$2<BuildRESTFunction$2<typeof publishDraftPost$1> & typeof publishDraftPost$1>;
 
 type _publicOnDraftCreatedType = typeof onDraftCreated$1;
 /**
@@ -5453,6 +7085,416 @@ declare namespace context$2 {
   export { context$2_Action as Action, type ActionEvent$2 as ActionEvent, Alignment$1 as Alignment, type AnchorData$1 as AnchorData, type AppEmbedData$1 as AppEmbedData, type AppEmbedDataAppDataOneOf$1 as AppEmbedDataAppDataOneOf, AppType$1 as AppType, type ApplicationError$1 as ApplicationError, type context$2_ApproveDraftPostRequest as ApproveDraftPostRequest, type context$2_ApproveDraftPostResponse as ApproveDraftPostResponse, type AudioData$1 as AudioData, type Background$1 as Background, type BackgroundBackgroundOneOf$1 as BackgroundBackgroundOneOf, BackgroundType$1 as BackgroundType, type BaseEventMetadata$2 as BaseEventMetadata, type BlockquoteData$1 as BlockquoteData, type BlogPaging$1 as BlogPaging, type BookingData$1 as BookingData, type Border$1 as Border, type BorderColors$1 as BorderColors, type BulkActionMetadata$1 as BulkActionMetadata, type context$2_BulkCreateDraftPostsOptions as BulkCreateDraftPostsOptions, type context$2_BulkCreateDraftPostsRequest as BulkCreateDraftPostsRequest, type context$2_BulkCreateDraftPostsResponse as BulkCreateDraftPostsResponse, type context$2_BulkCreateDraftPostsResponseNonNullableFields as BulkCreateDraftPostsResponseNonNullableFields, type context$2_BulkDeleteDraftPostsOptions as BulkDeleteDraftPostsOptions, type context$2_BulkDeleteDraftPostsRequest as BulkDeleteDraftPostsRequest, type context$2_BulkDeleteDraftPostsResponse as BulkDeleteDraftPostsResponse, type context$2_BulkDeleteDraftPostsResponseNonNullableFields as BulkDeleteDraftPostsResponseNonNullableFields, type context$2_BulkDraftPostResult as BulkDraftPostResult, type context$2_BulkRejectDraftPostRequest as BulkRejectDraftPostRequest, type context$2_BulkRejectDraftPostResponse as BulkRejectDraftPostResponse, type context$2_BulkRevertToUnpublishedRequest as BulkRevertToUnpublishedRequest, type context$2_BulkRevertToUnpublishedResponse as BulkRevertToUnpublishedResponse, type context$2_BulkUpdateDraftPostLanguageRequest as BulkUpdateDraftPostLanguageRequest, type context$2_BulkUpdateDraftPostLanguageResponse as BulkUpdateDraftPostLanguageResponse, type context$2_BulkUpdateDraftPostsOptions as BulkUpdateDraftPostsOptions, type context$2_BulkUpdateDraftPostsRequest as BulkUpdateDraftPostsRequest, type context$2_BulkUpdateDraftPostsResponse as BulkUpdateDraftPostsResponse, type context$2_BulkUpdateDraftPostsResponseNonNullableFields as BulkUpdateDraftPostsResponseNonNullableFields, type BulletedListData$1 as BulletedListData, type ButtonData$1 as ButtonData, context$2_ButtonDataType as ButtonDataType, type Category$1 as Category, type CategoryTranslation$1 as CategoryTranslation, type CellStyle$1 as CellStyle, type CodeBlockData$1 as CodeBlockData, type CollapsibleListData$1 as CollapsibleListData, type ColorData$1 as ColorData, type Colors$1 as Colors, type CoverMedia$1 as CoverMedia, type CoverMediaMediaOneOf$1 as CoverMediaMediaOneOf, type context$2_CreateDraftPostOptions as CreateDraftPostOptions, type context$2_CreateDraftPostRequest as CreateDraftPostRequest, type context$2_CreateDraftPostResponse as CreateDraftPostResponse, type context$2_CreateDraftPostResponseNonNullableFields as CreateDraftPostResponseNonNullableFields, Crop$1 as Crop, type CursorPaging$2 as CursorPaging, type Cursors$2 as Cursors, type Decoration$1 as Decoration, type DecorationDataOneOf$1 as DecorationDataOneOf, DecorationType$1 as DecorationType, type context$2_DeleteDraftPostOptions as DeleteDraftPostOptions, type context$2_DeleteDraftPostRequest as DeleteDraftPostRequest, type context$2_DeleteDraftPostResponse as DeleteDraftPostResponse, type Design$1 as Design, type Dimensions$1 as Dimensions, Direction$1 as Direction, type DividerData$1 as DividerData, type DocumentStyle$1 as DocumentStyle, type DomainEvent$2 as DomainEvent, type DomainEventBodyOneOf$2 as DomainEventBodyOneOf, type context$2_DraftCreatedEnvelope as DraftCreatedEnvelope, type context$2_DraftDeletedEnvelope as DraftDeletedEnvelope, type DraftPost$1 as DraftPost, type context$2_DraftPostOwnerChanged as DraftPostOwnerChanged, type DraftPostTranslation$1 as DraftPostTranslation, type context$2_DraftPostsQueryBuilder as DraftPostsQueryBuilder, type context$2_DraftPostsQueryResult as DraftPostsQueryResult, type context$2_DraftUpdatedEnvelope as DraftUpdatedEnvelope, type EmbedData$1 as EmbedData, type EmbedMedia$1 as EmbedMedia, type EmbedThumbnail$1 as EmbedThumbnail, type EmbedVideo$1 as EmbedVideo, type EntityCreatedEvent$2 as EntityCreatedEvent, type EntityDeletedEvent$2 as EntityDeletedEvent, type EntityUpdatedEvent$2 as EntityUpdatedEvent, type EventData$1 as EventData, type EventMetadata$2 as EventMetadata, Field$2 as Field, type FileData$1 as FileData, type FileSource$1 as FileSource, type FileSourceDataOneOf$1 as FileSourceDataOneOf, type FontSizeData$1 as FontSizeData, FontType$1 as FontType, type GIF$1 as GIF, type GIFData$1 as GIFData, type GalleryData$1 as GalleryData, type GalleryOptions$1 as GalleryOptions, type context$2_GetDeletedDraftPostRequest as GetDeletedDraftPostRequest, type context$2_GetDeletedDraftPostResponse as GetDeletedDraftPostResponse, type context$2_GetDeletedDraftPostResponseNonNullableFields as GetDeletedDraftPostResponseNonNullableFields, type context$2_GetDraftPostOptions as GetDraftPostOptions, type context$2_GetDraftPostRequest as GetDraftPostRequest, type context$2_GetDraftPostResponse as GetDraftPostResponse, type context$2_GetDraftPostResponseNonNullableFields as GetDraftPostResponseNonNullableFields, type context$2_GetDraftPostTotalsRequest as GetDraftPostTotalsRequest, type context$2_GetDraftPostTotalsResponse as GetDraftPostTotalsResponse, context$2_GetDraftPostsSort as GetDraftPostsSort, type context$2_GetPostAmountsByLanguageRequest as GetPostAmountsByLanguageRequest, type context$2_GetPostAmountsByLanguageResponse as GetPostAmountsByLanguageResponse, type Gradient$1 as Gradient, type HTMLData$1 as HTMLData, type HTMLDataDataOneOf$1 as HTMLDataDataOneOf, type HeadingData$1 as HeadingData, type Height$1 as Height, type IdentificationData$2 as IdentificationData, type IdentificationDataIdOneOf$2 as IdentificationDataIdOneOf, type Image$1 as Image, type ImageData$1 as ImageData, type context$2_InitialDraftPostsCopied as InitialDraftPostsCopied, InitialExpandedItems$1 as InitialExpandedItems, type context$2_IsDraftPostAutoTranslatableRequest as IsDraftPostAutoTranslatableRequest, type context$2_IsDraftPostAutoTranslatableResponse as IsDraftPostAutoTranslatableResponse, type Item$1 as Item, type ItemDataOneOf$1 as ItemDataOneOf, type ItemMetadata$1 as ItemMetadata, type ItemStyle$1 as ItemStyle, type Keyword$2 as Keyword, type Layout$1 as Layout, LayoutType$1 as LayoutType, LineStyle$1 as LineStyle, type Link$1 as Link, type LinkData$1 as LinkData, type LinkDataOneOf$1 as LinkDataOneOf, type LinkPreviewData$1 as LinkPreviewData, type context$2_ListDeletedDraftPostsOptions as ListDeletedDraftPostsOptions, type context$2_ListDeletedDraftPostsRequest as ListDeletedDraftPostsRequest, type context$2_ListDeletedDraftPostsResponse as ListDeletedDraftPostsResponse, type context$2_ListDeletedDraftPostsResponseNonNullableFields as ListDeletedDraftPostsResponseNonNullableFields, type context$2_ListDraftPostsOptions as ListDraftPostsOptions, type context$2_ListDraftPostsRequest as ListDraftPostsRequest, type context$2_ListDraftPostsResponse as ListDraftPostsResponse, type context$2_ListDraftPostsResponseNonNullableFields as ListDraftPostsResponseNonNullableFields, type ListValue$1 as ListValue, type MapData$1 as MapData, type MapSettings$1 as MapSettings, MapType$1 as MapType, type context$2_MarkPostAsInModerationRequest as MarkPostAsInModerationRequest, type context$2_MarkPostAsInModerationResponse as MarkPostAsInModerationResponse, type context$2_MaskedDraftPosts as MaskedDraftPosts, type Media$1 as Media, type MediaMediaOneOf$1 as MediaMediaOneOf, type MentionData$1 as MentionData, type MessageEnvelope$2 as MessageEnvelope, type MetaData$2 as MetaData, type Metadata$1 as Metadata, type ModerationDetails$1 as ModerationDetails, ModerationStatusStatus$1 as ModerationStatusStatus, type Node$1 as Node, type NodeDataOneOf$1 as NodeDataOneOf, type NodeStyle$1 as NodeStyle, NodeType$1 as NodeType, NullValue$1 as NullValue, type Oembed$1 as Oembed, type Option$1 as Option, type OptionDesign$1 as OptionDesign, type OptionLayout$1 as OptionLayout, type OrderedListData$1 as OrderedListData, Orientation$1 as Orientation, Origin$1 as Origin, type PDFSettings$1 as PDFSettings, type Paging$2 as Paging, type PagingMetadataV2$2 as PagingMetadataV2, type ParagraphData$1 as ParagraphData, type Permissions$1 as Permissions, type PlatformQuery$2 as PlatformQuery, type PlatformQueryPagingMethodOneOf$2 as PlatformQueryPagingMethodOneOf, type PlaybackOptions$1 as PlaybackOptions, type PluginContainerData$1 as PluginContainerData, PluginContainerDataAlignment$1 as PluginContainerDataAlignment, type PluginContainerDataWidth$1 as PluginContainerDataWidth, type PluginContainerDataWidthDataOneOf$1 as PluginContainerDataWidthDataOneOf, type Poll$1 as Poll, type PollData$1 as PollData, type PollDataLayout$1 as PollDataLayout, type PollDesign$1 as PollDesign, type PollLayout$1 as PollLayout, PollLayoutDirection$1 as PollLayoutDirection, PollLayoutType$1 as PollLayoutType, type PollSettings$1 as PollSettings, type context$2_PostAmountByLanguage as PostAmountByLanguage, type context$2_PublishDraftPostRequest as PublishDraftPostRequest, type context$2_PublishDraftPostResponse as PublishDraftPostResponse, type context$2_PublishDraftPostResponseNonNullableFields as PublishDraftPostResponseNonNullableFields, type context$2_QueryDraftPostsOptions as QueryDraftPostsOptions, type context$2_QueryDraftPostsRequest as QueryDraftPostsRequest, type context$2_QueryDraftPostsResponse as QueryDraftPostsResponse, type context$2_QueryDraftPostsResponseNonNullableFields as QueryDraftPostsResponseNonNullableFields, type context$2_RejectDraftPostRequest as RejectDraftPostRequest, type context$2_RejectDraftPostResponse as RejectDraftPostResponse, type Rel$1 as Rel, type context$2_RemoveFromTrashBinRequest as RemoveFromTrashBinRequest, type context$2_RemoveFromTrashBinResponse as RemoveFromTrashBinResponse, type context$2_RestoreFromTrashBinRequest as RestoreFromTrashBinRequest, type context$2_RestoreFromTrashBinResponse as RestoreFromTrashBinResponse, type context$2_RestoreFromTrashBinResponseNonNullableFields as RestoreFromTrashBinResponseNonNullableFields, type RestoreInfo$2 as RestoreInfo, type context$2_RevertToUnpublishedRequest as RevertToUnpublishedRequest, type context$2_RevertToUnpublishedResponse as RevertToUnpublishedResponse, type RichContent$1 as RichContent, type SeoSchema$2 as SeoSchema, type Settings$2 as Settings, SortOrder$2 as SortOrder, type Sorting$2 as Sorting, Source$1 as Source, type Spoiler$1 as Spoiler, type SpoilerData$1 as SpoilerData, Status$1 as Status, type Styles$1 as Styles, type TableCellData$1 as TableCellData, type TableData$1 as TableData, type Tag$2 as Tag, Target$1 as Target, TextAlignment$1 as TextAlignment, type TextData$1 as TextData, type TextNodeStyle$1 as TextNodeStyle, type TextStyle$1 as TextStyle, type Thumbnails$1 as Thumbnails, ThumbnailsAlignment$1 as ThumbnailsAlignment, type context$2_TotalDraftPosts as TotalDraftPosts, context$2_TotalDraftPostsGroupingField as TotalDraftPostsGroupingField, type context$2_TranslateCategoryRequest as TranslateCategoryRequest, type context$2_TranslateCategoryResponse as TranslateCategoryResponse, type context$2_TranslateDraftRequest as TranslateDraftRequest, type context$2_TranslateDraftResponse as TranslateDraftResponse, Type$1 as Type, type context$2_UnpublishPostRequest as UnpublishPostRequest, type context$2_UnpublishPostResponse as UnpublishPostResponse, type context$2_UpdateDraftPost as UpdateDraftPost, type context$2_UpdateDraftPostContentRequest as UpdateDraftPostContentRequest, type context$2_UpdateDraftPostContentRequestDraftContentOneOf as UpdateDraftPostContentRequestDraftContentOneOf, type context$2_UpdateDraftPostContentResponse as UpdateDraftPostContentResponse, type context$2_UpdateDraftPostLanguageRequest as UpdateDraftPostLanguageRequest, type context$2_UpdateDraftPostLanguageResponse as UpdateDraftPostLanguageResponse, type context$2_UpdateDraftPostOptions as UpdateDraftPostOptions, type context$2_UpdateDraftPostRequest as UpdateDraftPostRequest, type context$2_UpdateDraftPostResponse as UpdateDraftPostResponse, type context$2_UpdateDraftPostResponseNonNullableFields as UpdateDraftPostResponseNonNullableFields, type V1Media$1 as V1Media, VerticalAlignment$1 as VerticalAlignment, type Video$1 as Video, type VideoData$1 as VideoData, type VideoResolution$1 as VideoResolution, ViewMode$1 as ViewMode, ViewRole$1 as ViewRole, VoteRole$1 as VoteRole, WebhookIdentityType$2 as WebhookIdentityType, Width$1 as Width, WidthType$1 as WidthType, type WixMedia$1 as WixMedia, type context$2__publicOnDraftCreatedType as _publicOnDraftCreatedType, type context$2__publicOnDraftDeletedType as _publicOnDraftDeletedType, type context$2__publicOnDraftUpdatedType as _publicOnDraftUpdatedType, context$2_bulkCreateDraftPosts as bulkCreateDraftPosts, context$2_bulkDeleteDraftPosts as bulkDeleteDraftPosts, context$2_bulkUpdateDraftPosts as bulkUpdateDraftPosts, context$2_createDraftPost as createDraftPost, context$2_deleteDraftPost as deleteDraftPost, context$2_getDeletedDraftPost as getDeletedDraftPost, context$2_getDraftPost as getDraftPost, context$2_listDeletedDraftPosts as listDeletedDraftPosts, context$2_listDraftPosts as listDraftPosts, context$2_onDraftCreated as onDraftCreated, context$2_onDraftDeleted as onDraftDeleted, context$2_onDraftUpdated as onDraftUpdated, onDraftCreated$1 as publicOnDraftCreated, onDraftDeleted$1 as publicOnDraftDeleted, onDraftUpdated$1 as publicOnDraftUpdated, context$2_publishDraftPost as publishDraftPost, context$2_queryDraftPosts as queryDraftPosts, context$2_removeFromTrashBin as removeFromTrashBin, context$2_restoreFromTrashBin as restoreFromTrashBin, context$2_updateDraftPost as updateDraftPost };
 }
 
+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 bast url to use for API requests, for example `www.wixapis.com`
+     */
+    apiBaseUrl?: string;
+    /**
+     * Possible data to be provided by every host, for cross cutting concerns
+     * like internationalization, billing, etc.
+     */
+    essentials?: {
+        /**
+         * The language of the currently viewed session
+         */
+        language?: string;
+        /**
+         * The locale of the currently viewed session
+         */
+        locale?: string;
+        /**
+         * Any headers that should be passed through to the API requests
+         */
+        passThroughHeaders?: Record<string, string>;
+    };
+};
+
+type RESTFunctionDescriptor$1<T extends (...args: any[]) => any = (...args: any[]) => any> = (httpClient: HttpClient$1) => T;
+interface HttpClient$1 {
+    request<TResponse, TData = any>(req: RequestOptionsFactory$1<TResponse, TData>): Promise<HttpResponse$1<TResponse>>;
+    fetchWithAuth: typeof fetch;
+    wixAPIFetch: (relativeUrl: string, options: RequestInit) => Promise<Response>;
+    getActiveToken?: () => string | undefined;
+}
+type RequestOptionsFactory$1<TResponse = any, TData = any> = (context: any) => RequestOptions$1<TResponse, TData>;
+type HttpResponse$1<T = any> = {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: any;
+    request?: any;
+};
+type RequestOptions$1<_TResponse = any, Data = any> = {
+    method: 'POST' | 'GET' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+    url: string;
+    data?: Data;
+    params?: URLSearchParams;
+} & APIMetadata$1;
+type APIMetadata$1 = {
+    methodFqn?: string;
+    entityFqdn?: string;
+    packageName?: string;
+};
+type BuildRESTFunction$1<T extends RESTFunctionDescriptor$1> = T extends RESTFunctionDescriptor$1<infer U> ? U : never;
+type EventDefinition$3<Payload = unknown, Type extends string = string> = {
+    __type: 'event-definition';
+    type: Type;
+    isDomainEvent?: boolean;
+    transformations?: (envelope: unknown) => Payload;
+    __payload: Payload;
+};
+declare function EventDefinition$3<Type extends string>(type: Type, isDomainEvent?: boolean, transformations?: (envelope: any) => unknown): <Payload = unknown>() => EventDefinition$3<Payload, Type>;
+type EventHandler$3<T extends EventDefinition$3> = (payload: T['__payload']) => void | Promise<void>;
+type BuildEventDefinition$3<T extends EventDefinition$3<any, string>> = (handler: EventHandler$3<T>) => void;
+
+type ServicePluginMethodInput$1 = {
+    request: any;
+    metadata: any;
+};
+type ServicePluginContract$1 = Record<string, (payload: ServicePluginMethodInput$1) => unknown | Promise<unknown>>;
+type ServicePluginMethodMetadata$1 = {
+    name: string;
+    primaryHttpMappingPath: string;
+    transformations: {
+        fromREST: (...args: unknown[]) => ServicePluginMethodInput$1;
+        toREST: (...args: unknown[]) => unknown;
+    };
+};
+type ServicePluginDefinition$1<Contract extends ServicePluginContract$1> = {
+    __type: 'service-plugin-definition';
+    componentType: string;
+    methods: ServicePluginMethodMetadata$1[];
+    __contract: Contract;
+};
+declare function ServicePluginDefinition$1<Contract extends ServicePluginContract$1>(componentType: string, methods: ServicePluginMethodMetadata$1[]): ServicePluginDefinition$1<Contract>;
+type BuildServicePluginDefinition$1<T extends ServicePluginDefinition$1<any>> = (implementation: T['__contract']) => void;
+declare const SERVICE_PLUGIN_ERROR_TYPE$1 = "wix_spi_error";
+
+type RequestContext$1 = {
+    isSSR: boolean;
+    host: string;
+    protocol?: string;
+};
+type ResponseTransformer$1 = (data: any, headers?: any) => any;
+/**
+ * Ambassador request options types are copied mostly from AxiosRequestConfig.
+ * They are copied and not imported to reduce the amount of dependencies (to reduce install time).
+ * https://github.com/axios/axios/blob/3f53eb6960f05a1f88409c4b731a40de595cb825/index.d.ts#L307-L315
+ */
+type Method$1 = 'get' | 'GET' | 'delete' | 'DELETE' | 'head' | 'HEAD' | 'options' | 'OPTIONS' | 'post' | 'POST' | 'put' | 'PUT' | 'patch' | 'PATCH' | 'purge' | 'PURGE' | 'link' | 'LINK' | 'unlink' | 'UNLINK';
+type AmbassadorRequestOptions$1<T = any> = {
+    _?: T;
+    url?: string;
+    method?: Method$1;
+    params?: any;
+    data?: any;
+    transformResponse?: ResponseTransformer$1 | ResponseTransformer$1[];
+};
+type AmbassadorFactory$1<Request, Response> = (payload: Request) => ((context: RequestContext$1) => AmbassadorRequestOptions$1<Response>) & {
+    __isAmbassador: boolean;
+};
+type AmbassadorFunctionDescriptor$1<Request = any, Response = any> = AmbassadorFactory$1<Request, Response>;
+type BuildAmbassadorFunction$1<T extends AmbassadorFunctionDescriptor$1> = T extends AmbassadorFunctionDescriptor$1<infer Request, infer Response> ? (req: Request) => Promise<Response> : never;
+
+declare global {
+	// eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
+	interface SymbolConstructor {
+		readonly observable: symbol;
+	}
+}
+
+declare const emptyObjectSymbol$1: unique symbol;
+
+/**
+Represents a strictly empty plain object, the `{}` value.
+
+When you annotate something as the type `{}`, it can be anything except `null` and `undefined`. This means that you cannot use `{}` to represent an empty plain object ([read more](https://stackoverflow.com/questions/47339869/typescript-empty-object-and-any-difference/52193484#52193484)).
+
+@example
+```
+import type {EmptyObject} from 'type-fest';
+
+// The following illustrates the problem with `{}`.
+const foo1: {} = {}; // Pass
+const foo2: {} = []; // Pass
+const foo3: {} = 42; // Pass
+const foo4: {} = {a: 1}; // Pass
+
+// With `EmptyObject` only the first case is valid.
+const bar1: EmptyObject = {}; // Pass
+const bar2: EmptyObject = 42; // Fail
+const bar3: EmptyObject = []; // Fail
+const bar4: EmptyObject = {a: 1}; // Fail
+```
+
+Unfortunately, `Record<string, never>`, `Record<keyof any, never>` and `Record<never, never>` do not work. See {@link https://github.com/sindresorhus/type-fest/issues/395 #395}.
+
+@category Object
+*/
+type EmptyObject$1 = {[emptyObjectSymbol$1]?: never};
+
+/**
+Returns a boolean for whether the two given types are equal.
+
+@link https://github.com/microsoft/TypeScript/issues/27024#issuecomment-421529650
+@link https://stackoverflow.com/questions/68961864/how-does-the-equals-work-in-typescript/68963796#68963796
+
+Use-cases:
+- If you want to make a conditional branch based on the result of a comparison of two types.
+
+@example
+```
+import type {IsEqual} from 'type-fest';
+
+// This type returns a boolean for whether the given array includes the given item.
+// `IsEqual` is used to compare the given array at position 0 and the given item and then return true if they are equal.
+type Includes<Value extends readonly any[], Item> =
+	Value extends readonly [Value[0], ...infer rest]
+		? IsEqual<Value[0], Item> extends true
+			? true
+			: Includes<rest, Item>
+		: false;
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsEqual$1<A, B> =
+	(<G>() => G extends A ? 1 : 2) extends
+	(<G>() => G extends B ? 1 : 2)
+		? true
+		: false;
+
+/**
+Filter out keys from an object.
+
+Returns `never` if `Exclude` is strictly equal to `Key`.
+Returns `never` if `Key` extends `Exclude`.
+Returns `Key` otherwise.
+
+@example
+```
+type Filtered = Filter<'foo', 'foo'>;
+//=> never
+```
+
+@example
+```
+type Filtered = Filter<'bar', string>;
+//=> never
+```
+
+@example
+```
+type Filtered = Filter<'bar', 'foo'>;
+//=> 'bar'
+```
+
+@see {Except}
+*/
+type Filter$1<KeyType, ExcludeType> = IsEqual$1<KeyType, ExcludeType> extends true ? never : (KeyType extends ExcludeType ? never : KeyType);
+
+type ExceptOptions$1 = {
+	/**
+	Disallow assigning non-specified properties.
+
+	Note that any omitted properties in the resulting type will be present in autocomplete as `undefined`.
+
+	@default false
+	*/
+	requireExactProps?: boolean;
+};
+
+/**
+Create a type from an object type without certain keys.
+
+We recommend setting the `requireExactProps` option to `true`.
+
+This type is a stricter version of [`Omit`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-5.html#the-omit-helper-type). The `Omit` type does not restrict the omitted keys to be keys present on the given type, while `Except` does. The benefits of a stricter type are avoiding typos and allowing the compiler to pick up on rename refactors automatically.
+
+This type was proposed to the TypeScript team, which declined it, saying they prefer that libraries implement stricter versions of the built-in types ([microsoft/TypeScript#30825](https://github.com/microsoft/TypeScript/issues/30825#issuecomment-523668235)).
+
+@example
+```
+import type {Except} from 'type-fest';
+
+type Foo = {
+	a: number;
+	b: string;
+};
+
+type FooWithoutA = Except<Foo, 'a'>;
+//=> {b: string}
+
+const fooWithoutA: FooWithoutA = {a: 1, b: '2'};
+//=> errors: 'a' does not exist in type '{ b: string; }'
+
+type FooWithoutB = Except<Foo, 'b', {requireExactProps: true}>;
+//=> {a: number} & Partial<Record<"b", never>>
+
+const fooWithoutB: FooWithoutB = {a: 1, b: '2'};
+//=> errors at 'b': Type 'string' is not assignable to type 'undefined'.
+```
+
+@category Object
+*/
+type Except$1<ObjectType, KeysType extends keyof ObjectType, Options extends ExceptOptions$1 = {requireExactProps: false}> = {
+	[KeyType in keyof ObjectType as Filter$1<KeyType, KeysType>]: ObjectType[KeyType];
+} & (Options['requireExactProps'] extends true
+	? Partial<Record<KeysType, never>>
+	: {});
+
+/**
+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> = NonNullable<
+// Wrap in `NonNullable` to strip away the `undefined` type from the produced union.
+{
+	// 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 since the condition passes.
+		? 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$3<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$3<any> ? BuildEventDefinition$3<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;
+
 interface Post {
     /**
      * Post ID.
@@ -8934,7 +10976,7 @@ interface GetTotalPostsOptions {
     language?: string | null;
 }
 
-declare function getPost$1(httpClient: HttpClient): GetPostSignature;
+declare function getPost$1(httpClient: HttpClient$1): GetPostSignature;
 interface GetPostSignature {
     /**
      * Gets a post by the specified ID.
@@ -8948,7 +10990,7 @@ interface GetPostSignature {
      */
     (postId: string, options?: GetPostOptions | undefined): Promise<GetPostResponse & GetPostResponseNonNullableFields>;
 }
-declare function getPostBySlug$1(httpClient: HttpClient): GetPostBySlugSignature;
+declare function getPostBySlug$1(httpClient: HttpClient$1): GetPostBySlugSignature;
 interface GetPostBySlugSignature {
     /**
      * Gets a post by the provided slug.
@@ -8965,7 +11007,7 @@ interface GetPostBySlugSignature {
      */
     (slug: string, options?: GetPostBySlugOptions | undefined): Promise<GetPostBySlugResponse & GetPostBySlugResponseNonNullableFields>;
 }
-declare function listPosts$1(httpClient: HttpClient): ListPostsSignature;
+declare function listPosts$1(httpClient: HttpClient$1): ListPostsSignature;
 interface ListPostsSignature {
     /**
      * Retrieves a list of published posts.
@@ -8981,7 +11023,7 @@ interface ListPostsSignature {
      */
     (options?: ListPostsOptions | undefined): Promise<ListPostsResponse & ListPostsResponseNonNullableFields>;
 }
-declare function queryPosts$1(httpClient: HttpClient): QueryPostsSignature;
+declare function queryPosts$1(httpClient: HttpClient$1): QueryPostsSignature;
 interface QueryPostsSignature {
     /**
      * Creates a query to retrieve a list of posts.
@@ -9006,7 +11048,7 @@ interface QueryPostsSignature {
      */
     (options?: QueryPostsOptions | undefined): PostsQueryBuilder;
 }
-declare function getPostMetrics$1(httpClient: HttpClient): GetPostMetricsSignature;
+declare function getPostMetrics$1(httpClient: HttpClient$1): GetPostMetricsSignature;
 interface GetPostMetricsSignature {
     /**
      * Gets a specified post's metrics.
@@ -9020,7 +11062,7 @@ interface GetPostMetricsSignature {
      */
     (postId: string): Promise<GetPostMetricsResponse & GetPostMetricsResponseNonNullableFields>;
 }
-declare function queryPostCountStats$1(httpClient: HttpClient): QueryPostCountStatsSignature;
+declare function queryPostCountStats$1(httpClient: HttpClient$1): QueryPostCountStatsSignature;
 interface QueryPostCountStatsSignature {
     /**
      * Retrieves the number of published posts per month within a specified time range.
@@ -9036,7 +11078,7 @@ interface QueryPostCountStatsSignature {
      */
     (options?: QueryPostCountStatsOptions | undefined): Promise<QueryPostCountStatsResponse & QueryPostCountStatsResponseNonNullableFields>;
 }
-declare function getTotalPosts$1(httpClient: HttpClient): GetTotalPostsSignature;
+declare function getTotalPosts$1(httpClient: HttpClient$1): GetTotalPostsSignature;
 interface GetTotalPostsSignature {
     /**
      * Gets the total amount of published posts on the blog.
@@ -9051,21 +11093,39 @@ interface GetTotalPostsSignature {
      */
     (options?: GetTotalPostsOptions | undefined): Promise<GetTotalPostsResponse & GetTotalPostsResponseNonNullableFields>;
 }
-declare const onPostCreated$1: EventDefinition<PostCreatedEnvelope, "wix.blog.v3.post_created">;
-declare const onPostUpdated$1: EventDefinition<PostUpdatedEnvelope, "wix.blog.v3.post_updated">;
-declare const onPostDeleted$1: EventDefinition<PostDeletedEnvelope, "wix.blog.v3.post_deleted">;
-declare const onPostLiked$1: EventDefinition<PostLikedEnvelope, "wix.blog.v3.post_liked">;
-declare const onPostUnliked$1: EventDefinition<PostUnlikedEnvelope, "wix.blog.v3.post_unliked">;
+declare const onPostCreated$1: EventDefinition$3<PostCreatedEnvelope, "wix.blog.v3.post_created">;
+declare const onPostUpdated$1: EventDefinition$3<PostUpdatedEnvelope, "wix.blog.v3.post_updated">;
+declare const onPostDeleted$1: EventDefinition$3<PostDeletedEnvelope, "wix.blog.v3.post_deleted">;
+declare const onPostLiked$1: EventDefinition$3<PostLikedEnvelope, "wix.blog.v3.post_liked">;
+declare const onPostUnliked$1: EventDefinition$3<PostUnlikedEnvelope, "wix.blog.v3.post_unliked">;
+
+type EventDefinition$2<Payload = unknown, Type extends string = string> = {
+    __type: 'event-definition';
+    type: Type;
+    isDomainEvent?: boolean;
+    transformations?: (envelope: unknown) => Payload;
+    __payload: Payload;
+};
+declare function EventDefinition$2<Type extends string>(type: Type, isDomainEvent?: boolean, transformations?: (envelope: any) => unknown): <Payload = unknown>() => EventDefinition$2<Payload, Type>;
+type EventHandler$2<T extends EventDefinition$2> = (payload: T['__payload']) => void | Promise<void>;
+type BuildEventDefinition$2<T extends EventDefinition$2<any, string>> = (handler: EventHandler$2<T>) => void;
+
+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 function createEventModule$1<T extends EventDefinition<any, string>>(eventDefinition: T): BuildEventDefinition<T> & T;
+declare function createEventModule$1<T extends EventDefinition$2<any, string>>(eventDefinition: T): BuildEventDefinition$2<T> & T;
 
-declare const getPost: BuildRESTFunction<typeof getPost$1> & typeof getPost$1;
-declare const getPostBySlug: BuildRESTFunction<typeof getPostBySlug$1> & typeof getPostBySlug$1;
-declare const listPosts: BuildRESTFunction<typeof listPosts$1> & typeof listPosts$1;
-declare const queryPosts: BuildRESTFunction<typeof queryPosts$1> & typeof queryPosts$1;
-declare const getPostMetrics: BuildRESTFunction<typeof getPostMetrics$1> & typeof getPostMetrics$1;
-declare const queryPostCountStats: BuildRESTFunction<typeof queryPostCountStats$1> & typeof queryPostCountStats$1;
-declare const getTotalPosts: BuildRESTFunction<typeof getTotalPosts$1> & typeof getTotalPosts$1;
+declare const getPost: MaybeContext$1<BuildRESTFunction$1<typeof getPost$1> & typeof getPost$1>;
+declare const getPostBySlug: MaybeContext$1<BuildRESTFunction$1<typeof getPostBySlug$1> & typeof getPostBySlug$1>;
+declare const listPosts: MaybeContext$1<BuildRESTFunction$1<typeof listPosts$1> & typeof listPosts$1>;
+declare const queryPosts: MaybeContext$1<BuildRESTFunction$1<typeof queryPosts$1> & typeof queryPosts$1>;
+declare const getPostMetrics: MaybeContext$1<BuildRESTFunction$1<typeof getPostMetrics$1> & typeof getPostMetrics$1>;
+declare const queryPostCountStats: MaybeContext$1<BuildRESTFunction$1<typeof queryPostCountStats$1> & typeof queryPostCountStats$1>;
+declare const getTotalPosts: MaybeContext$1<BuildRESTFunction$1<typeof getTotalPosts$1> & typeof getTotalPosts$1>;
 
 type _publicOnPostCreatedType = typeof onPostCreated$1;
 /**
@@ -9380,6 +11440,416 @@ declare namespace context$1 {
   export { type ActionEvent$1 as ActionEvent, context$1_Alignment as Alignment, type context$1_AnchorData as AnchorData, type context$1_AppEmbedData as AppEmbedData, type context$1_AppEmbedDataAppDataOneOf as AppEmbedDataAppDataOneOf, context$1_AppType as AppType, type context$1_AudioData as AudioData, type context$1_Background as Background, type context$1_BackgroundBackgroundOneOf as BackgroundBackgroundOneOf, context$1_BackgroundType as BackgroundType, type BaseEventMetadata$1 as BaseEventMetadata, type context$1_BlockquoteData as BlockquoteData, type context$1_BlogPaging as BlogPaging, type context$1_BookingData as BookingData, type context$1_Border as Border, type context$1_BorderColors as BorderColors, type context$1_BulkGetPostMetricsRequest as BulkGetPostMetricsRequest, type context$1_BulkGetPostMetricsResponse as BulkGetPostMetricsResponse, type context$1_BulkGetPostReactionsRequest as BulkGetPostReactionsRequest, type context$1_BulkGetPostReactionsResponse as BulkGetPostReactionsResponse, type context$1_BulletedListData as BulletedListData, type context$1_ButtonData as ButtonData, type context$1_Category as Category, type context$1_CategoryTranslation as CategoryTranslation, type context$1_CellStyle as CellStyle, type context$1_CodeBlockData as CodeBlockData, type context$1_CollapsibleListData as CollapsibleListData, type context$1_ColorData as ColorData, type context$1_Colors as Colors, type context$1_ConvertDraftJsToRichContentRequest as ConvertDraftJsToRichContentRequest, type context$1_ConvertDraftJsToRichContentResponse as ConvertDraftJsToRichContentResponse, type context$1_ConvertRichContentToDraftJsRequest as ConvertRichContentToDraftJsRequest, type context$1_ConvertRichContentToDraftJsResponse as ConvertRichContentToDraftJsResponse, type context$1_CoverMedia as CoverMedia, type context$1_CoverMediaMediaOneOf as CoverMediaMediaOneOf, type context$1_CreateDraftPostFromTemplateRequest as CreateDraftPostFromTemplateRequest, type context$1_CreateDraftPostFromTemplateResponse as CreateDraftPostFromTemplateResponse, context$1_Crop as Crop, type CursorPaging$1 as CursorPaging, type Cursors$1 as Cursors, type context$1_Decoration as Decoration, type context$1_DecorationDataOneOf as DecorationDataOneOf, context$1_DecorationType as DecorationType, type context$1_Design as Design, type context$1_Dimensions as Dimensions, context$1_Direction as Direction, type context$1_DividerData as DividerData, type context$1_DocumentStyle as DocumentStyle, type DomainEvent$1 as DomainEvent, type DomainEventBodyOneOf$1 as DomainEventBodyOneOf, type context$1_DraftPost as DraftPost, type context$1_DraftPostTranslation as DraftPostTranslation, type context$1_EmbedData as EmbedData, type context$1_EmbedMedia as EmbedMedia, type context$1_EmbedThumbnail as EmbedThumbnail, type context$1_EmbedVideo as EmbedVideo, type EntityCreatedEvent$1 as EntityCreatedEvent, type EntityDeletedEvent$1 as EntityDeletedEvent, type EntityUpdatedEvent$1 as EntityUpdatedEvent, type context$1_EventData as EventData, type EventMetadata$1 as EventMetadata, Field$1 as Field, type context$1_FileData as FileData, type context$1_FileSource as FileSource, type context$1_FileSourceDataOneOf as FileSourceDataOneOf, type context$1_FontSizeData as FontSizeData, context$1_FontType as FontType, type context$1_GIF as GIF, type context$1_GIFData as GIFData, type context$1_GalleryData as GalleryData, type context$1_GalleryOptions as GalleryOptions, type context$1_GetPostBySlugOptions as GetPostBySlugOptions, type context$1_GetPostBySlugRequest as GetPostBySlugRequest, type context$1_GetPostBySlugResponse as GetPostBySlugResponse, type context$1_GetPostBySlugResponseNonNullableFields as GetPostBySlugResponseNonNullableFields, type context$1_GetPostMetricsRequest as GetPostMetricsRequest, type context$1_GetPostMetricsResponse as GetPostMetricsResponse, type context$1_GetPostMetricsResponseNonNullableFields as GetPostMetricsResponseNonNullableFields, type context$1_GetPostOptions as GetPostOptions, type context$1_GetPostRequest as GetPostRequest, type context$1_GetPostResponse as GetPostResponse, type context$1_GetPostResponseNonNullableFields as GetPostResponseNonNullableFields, context$1_GetPostTemplatesSort as GetPostTemplatesSort, context$1_GetPostsSort as GetPostsSort, type context$1_GetTemplateRequest as GetTemplateRequest, type context$1_GetTemplateResponse as GetTemplateResponse, type context$1_GetTotalLikesPerMemberRequest as GetTotalLikesPerMemberRequest, type context$1_GetTotalLikesPerMemberResponse as GetTotalLikesPerMemberResponse, type context$1_GetTotalPostsOptions as GetTotalPostsOptions, type context$1_GetTotalPostsRequest as GetTotalPostsRequest, type context$1_GetTotalPostsResponse as GetTotalPostsResponse, type context$1_GetTotalPostsResponseNonNullableFields as GetTotalPostsResponseNonNullableFields, type context$1_GetTotalPublicationsRequest as GetTotalPublicationsRequest, type context$1_GetTotalPublicationsResponse as GetTotalPublicationsResponse, type context$1_Gradient as Gradient, type context$1_HTMLData as HTMLData, type context$1_HTMLDataDataOneOf as HTMLDataDataOneOf, type context$1_HeadingData as HeadingData, type context$1_Height as Height, type IdentificationData$1 as IdentificationData, type IdentificationDataIdOneOf$1 as IdentificationDataIdOneOf, type context$1_Image as Image, type context$1_ImageData as ImageData, context$1_InitialExpandedItems as InitialExpandedItems, type context$1_InitialPostsCopied as InitialPostsCopied, type context$1_Item as Item, type context$1_ItemDataOneOf as ItemDataOneOf, type context$1_ItemStyle as ItemStyle, type Keyword$1 as Keyword, type context$1_Layout as Layout, context$1_LayoutType as LayoutType, type context$1_LikePostRequest as LikePostRequest, type context$1_LikePostResponse as LikePostResponse, context$1_LineStyle as LineStyle, type context$1_Link as Link, type context$1_LinkData as LinkData, type context$1_LinkDataOneOf as LinkDataOneOf, type context$1_LinkPreviewData as LinkPreviewData, type context$1_ListDemoPostsRequest as ListDemoPostsRequest, type context$1_ListDemoPostsResponse as ListDemoPostsResponse, type context$1_ListPostsArchiveRequest as ListPostsArchiveRequest, type context$1_ListPostsArchiveResponse as ListPostsArchiveResponse, type context$1_ListPostsOptions as ListPostsOptions, type context$1_ListPostsRequest as ListPostsRequest, type context$1_ListPostsResponse as ListPostsResponse, type context$1_ListPostsResponseNonNullableFields as ListPostsResponseNonNullableFields, type context$1_ListTemplatesRequest as ListTemplatesRequest, type context$1_ListTemplatesResponse as ListTemplatesResponse, type context$1_ListValue as ListValue, type context$1_MapData as MapData, type context$1_MapSettings as MapSettings, context$1_MapType as MapType, type context$1_Media as Media, type context$1_MediaMediaOneOf as MediaMediaOneOf, type context$1_MentionData as MentionData, type MessageEnvelope$1 as MessageEnvelope, type MetaData$1 as MetaData, type context$1_Metadata as Metadata, type context$1_Metrics as Metrics, type context$1_ModerationDetails as ModerationDetails, context$1_ModerationStatusStatus as ModerationStatusStatus, type context$1_Node as Node, type context$1_NodeDataOneOf as NodeDataOneOf, type context$1_NodeStyle as NodeStyle, context$1_NodeType as NodeType, context$1_NullValue as NullValue, type context$1_Oembed as Oembed, type context$1_OldBlogMigratedEvent as OldBlogMigratedEvent, type context$1_Option as Option, type context$1_OptionDesign as OptionDesign, type context$1_OptionLayout as OptionLayout, context$1_Order as Order, type context$1_OrderedListData as OrderedListData, context$1_Orientation as Orientation, context$1_Origin as Origin, type context$1_PDFSettings as PDFSettings, type Paging$1 as Paging, type PagingMetadataV2$1 as PagingMetadataV2, type context$1_ParagraphData as ParagraphData, type context$1_PeriodPostCount as PeriodPostCount, type context$1_PeriodPublicationsCount as PeriodPublicationsCount, type context$1_Permissions as Permissions, type context$1_PinPostRequest as PinPostRequest, type context$1_PinPostResponse as PinPostResponse, type PlatformQuery$1 as PlatformQuery, type PlatformQueryPagingMethodOneOf$1 as PlatformQueryPagingMethodOneOf, type context$1_PlaybackOptions as PlaybackOptions, type context$1_PluginContainerData as PluginContainerData, context$1_PluginContainerDataAlignment as PluginContainerDataAlignment, type context$1_PluginContainerDataWidth as PluginContainerDataWidth, type context$1_PluginContainerDataWidthDataOneOf as PluginContainerDataWidthDataOneOf, type context$1_Poll as Poll, type context$1_PollData as PollData, type context$1_PollDataLayout as PollDataLayout, type context$1_PollDesign as PollDesign, type context$1_PollLayout as PollLayout, context$1_PollLayoutDirection as PollLayoutDirection, context$1_PollLayoutType as PollLayoutType, type context$1_PollSettings as PollSettings, type context$1_Post as Post, type context$1_PostCountInfo as PostCountInfo, type context$1_PostCountersUpdated as PostCountersUpdated, type context$1_PostCountersUpdatedInitiatorOneOf as PostCountersUpdatedInitiatorOneOf, type context$1_PostCreatedEnvelope as PostCreatedEnvelope, type context$1_PostDeletedEnvelope as PostDeletedEnvelope, context$1_PostFieldField as PostFieldField, type context$1_PostLiked as PostLiked, type context$1_PostLikedEnvelope as PostLikedEnvelope, type context$1_PostLikedInitiatorOneOf as PostLikedInitiatorOneOf, type context$1_PostOwnerChanged as PostOwnerChanged, type context$1_PostTranslation as PostTranslation, type context$1_PostUnliked as PostUnliked, type context$1_PostUnlikedEnvelope as PostUnlikedEnvelope, type context$1_PostUnlikedInitiatorOneOf as PostUnlikedInitiatorOneOf, type context$1_PostUpdatedEnvelope as PostUpdatedEnvelope, type context$1_PostsQueryBuilder as PostsQueryBuilder, type context$1_PostsQueryResult as PostsQueryResult, type context$1_QueryPostCountStatsOptions as QueryPostCountStatsOptions, type context$1_QueryPostCountStatsRequest as QueryPostCountStatsRequest, type context$1_QueryPostCountStatsResponse as QueryPostCountStatsResponse, type context$1_QueryPostCountStatsResponseNonNullableFields as QueryPostCountStatsResponseNonNullableFields, type context$1_QueryPostsOptions as QueryPostsOptions, type context$1_QueryPostsRequest as QueryPostsRequest, type context$1_QueryPostsResponse as QueryPostsResponse, type context$1_QueryPostsResponseNonNullableFields as QueryPostsResponseNonNullableFields, type context$1_QueryPublicationsCountStatsRequest as QueryPublicationsCountStatsRequest, context$1_QueryPublicationsCountStatsRequestOrder as QueryPublicationsCountStatsRequestOrder, type context$1_QueryPublicationsCountStatsResponse as QueryPublicationsCountStatsResponse, type context$1_Reactions as Reactions, type context$1_Rel as Rel, type RestoreInfo$1 as RestoreInfo, type context$1_RichContent as RichContent, type context$1_SendActionEventRequest as SendActionEventRequest, type context$1_SendActionEventRequestActionOneOf as SendActionEventRequestActionOneOf, type context$1_SendActionEventResponse as SendActionEventResponse, type SeoSchema$1 as SeoSchema, type Settings$1 as Settings, SortOrder$1 as SortOrder, type Sorting$1 as Sorting, context$1_Source as Source, type context$1_Spoiler as Spoiler, type context$1_SpoilerData as SpoilerData, context$1_Status as Status, type context$1_Styles as Styles, type context$1_TableCellData as TableCellData, type context$1_TableData as TableData, type Tag$1 as Tag, context$1_Target as Target, context$1_TextAlignment as TextAlignment, type context$1_TextData as TextData, type context$1_TextNodeStyle as TextNodeStyle, type context$1_TextStyle as TextStyle, type context$1_Thumbnails as Thumbnails, context$1_ThumbnailsAlignment as ThumbnailsAlignment, context$1_Type as Type, type context$1_UnlikePostRequest as UnlikePostRequest, type context$1_UnlikePostResponse as UnlikePostResponse, type context$1_UnpinPostRequest as UnpinPostRequest, type context$1_UnpinPostResponse as UnpinPostResponse, type context$1_V1Media as V1Media, context$1_VerticalAlignment as VerticalAlignment, type context$1_Video as Video, type context$1_VideoData as VideoData, type context$1_VideoResolution as VideoResolution, context$1_ViewMode as ViewMode, type context$1_ViewPostRequest as ViewPostRequest, type context$1_ViewPostResponse as ViewPostResponse, context$1_ViewRole as ViewRole, context$1_VoteRole as VoteRole, WebhookIdentityType$1 as WebhookIdentityType, context$1_Width as Width, context$1_WidthType as WidthType, type context$1_WixMedia as WixMedia, type context$1__publicOnPostCreatedType as _publicOnPostCreatedType, type context$1__publicOnPostDeletedType as _publicOnPostDeletedType, type context$1__publicOnPostLikedType as _publicOnPostLikedType, type context$1__publicOnPostUnlikedType as _publicOnPostUnlikedType, type context$1__publicOnPostUpdatedType as _publicOnPostUpdatedType, context$1_getPost as getPost, context$1_getPostBySlug as getPostBySlug, context$1_getPostMetrics as getPostMetrics, context$1_getTotalPosts as getTotalPosts, context$1_listPosts as listPosts, context$1_onPostCreated as onPostCreated, context$1_onPostDeleted as onPostDeleted, context$1_onPostLiked as onPostLiked, context$1_onPostUnliked as onPostUnliked, context$1_onPostUpdated as onPostUpdated, onPostCreated$1 as publicOnPostCreated, onPostDeleted$1 as publicOnPostDeleted, onPostLiked$1 as publicOnPostLiked, onPostUnliked$1 as publicOnPostUnliked, onPostUpdated$1 as publicOnPostUpdated, context$1_queryPostCountStats as queryPostCountStats, context$1_queryPosts as queryPosts };
 }
 
+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 bast url to use for API requests, for example `www.wixapis.com`
+     */
+    apiBaseUrl?: string;
+    /**
+     * Possible data to be provided by every host, for cross cutting concerns
+     * like internationalization, billing, etc.
+     */
+    essentials?: {
+        /**
+         * The language of the currently viewed session
+         */
+        language?: string;
+        /**
+         * The locale of the currently viewed session
+         */
+        locale?: string;
+        /**
+         * Any headers that should be passed through to the API requests
+         */
+        passThroughHeaders?: Record<string, string>;
+    };
+};
+
+type RESTFunctionDescriptor<T extends (...args: any[]) => any = (...args: any[]) => any> = (httpClient: HttpClient) => T;
+interface HttpClient {
+    request<TResponse, TData = any>(req: RequestOptionsFactory<TResponse, TData>): Promise<HttpResponse<TResponse>>;
+    fetchWithAuth: typeof fetch;
+    wixAPIFetch: (relativeUrl: string, options: RequestInit) => Promise<Response>;
+    getActiveToken?: () => string | undefined;
+}
+type RequestOptionsFactory<TResponse = any, TData = any> = (context: any) => RequestOptions<TResponse, TData>;
+type HttpResponse<T = any> = {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: any;
+    request?: any;
+};
+type RequestOptions<_TResponse = any, Data = any> = {
+    method: 'POST' | 'GET' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+    url: string;
+    data?: Data;
+    params?: URLSearchParams;
+} & APIMetadata;
+type APIMetadata = {
+    methodFqn?: string;
+    entityFqdn?: string;
+    packageName?: string;
+};
+type BuildRESTFunction<T extends RESTFunctionDescriptor> = T extends RESTFunctionDescriptor<infer U> ? U : never;
+type EventDefinition$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 = {
+    request: any;
+    metadata: any;
+};
+type ServicePluginContract = Record<string, (payload: ServicePluginMethodInput) => unknown | Promise<unknown>>;
+type ServicePluginMethodMetadata = {
+    name: string;
+    primaryHttpMappingPath: string;
+    transformations: {
+        fromREST: (...args: unknown[]) => ServicePluginMethodInput;
+        toREST: (...args: unknown[]) => unknown;
+    };
+};
+type ServicePluginDefinition<Contract extends ServicePluginContract> = {
+    __type: 'service-plugin-definition';
+    componentType: string;
+    methods: ServicePluginMethodMetadata[];
+    __contract: Contract;
+};
+declare function ServicePluginDefinition<Contract extends ServicePluginContract>(componentType: string, methods: ServicePluginMethodMetadata[]): ServicePluginDefinition<Contract>;
+type BuildServicePluginDefinition<T extends ServicePluginDefinition<any>> = (implementation: T['__contract']) => void;
+declare const SERVICE_PLUGIN_ERROR_TYPE = "wix_spi_error";
+
+type RequestContext = {
+    isSSR: boolean;
+    host: string;
+    protocol?: string;
+};
+type ResponseTransformer = (data: any, headers?: any) => any;
+/**
+ * Ambassador request options types are copied mostly from AxiosRequestConfig.
+ * They are copied and not imported to reduce the amount of dependencies (to reduce install time).
+ * https://github.com/axios/axios/blob/3f53eb6960f05a1f88409c4b731a40de595cb825/index.d.ts#L307-L315
+ */
+type Method = 'get' | 'GET' | 'delete' | 'DELETE' | 'head' | 'HEAD' | 'options' | 'OPTIONS' | 'post' | 'POST' | 'put' | 'PUT' | 'patch' | 'PATCH' | 'purge' | 'PURGE' | 'link' | 'LINK' | 'unlink' | 'UNLINK';
+type AmbassadorRequestOptions<T = any> = {
+    _?: T;
+    url?: string;
+    method?: Method;
+    params?: any;
+    data?: any;
+    transformResponse?: ResponseTransformer | ResponseTransformer[];
+};
+type AmbassadorFactory<Request, Response> = (payload: Request) => ((context: RequestContext) => AmbassadorRequestOptions<Response>) & {
+    __isAmbassador: boolean;
+};
+type AmbassadorFunctionDescriptor<Request = any, Response = any> = AmbassadorFactory<Request, Response>;
+type BuildAmbassadorFunction<T extends AmbassadorFunctionDescriptor> = T extends AmbassadorFunctionDescriptor<infer Request, infer Response> ? (req: Request) => Promise<Response> : never;
+
+declare global {
+	// eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
+	interface SymbolConstructor {
+		readonly observable: symbol;
+	}
+}
+
+declare const emptyObjectSymbol: unique symbol;
+
+/**
+Represents a strictly empty plain object, the `{}` value.
+
+When you annotate something as the type `{}`, it can be anything except `null` and `undefined`. This means that you cannot use `{}` to represent an empty plain object ([read more](https://stackoverflow.com/questions/47339869/typescript-empty-object-and-any-difference/52193484#52193484)).
+
+@example
+```
+import type {EmptyObject} from 'type-fest';
+
+// The following illustrates the problem with `{}`.
+const foo1: {} = {}; // Pass
+const foo2: {} = []; // Pass
+const foo3: {} = 42; // Pass
+const foo4: {} = {a: 1}; // Pass
+
+// With `EmptyObject` only the first case is valid.
+const bar1: EmptyObject = {}; // Pass
+const bar2: EmptyObject = 42; // Fail
+const bar3: EmptyObject = []; // Fail
+const bar4: EmptyObject = {a: 1}; // Fail
+```
+
+Unfortunately, `Record<string, never>`, `Record<keyof any, never>` and `Record<never, never>` do not work. See {@link https://github.com/sindresorhus/type-fest/issues/395 #395}.
+
+@category Object
+*/
+type EmptyObject = {[emptyObjectSymbol]?: never};
+
+/**
+Returns a boolean for whether the two given types are equal.
+
+@link https://github.com/microsoft/TypeScript/issues/27024#issuecomment-421529650
+@link https://stackoverflow.com/questions/68961864/how-does-the-equals-work-in-typescript/68963796#68963796
+
+Use-cases:
+- If you want to make a conditional branch based on the result of a comparison of two types.
+
+@example
+```
+import type {IsEqual} from 'type-fest';
+
+// This type returns a boolean for whether the given array includes the given item.
+// `IsEqual` is used to compare the given array at position 0 and the given item and then return true if they are equal.
+type Includes<Value extends readonly any[], Item> =
+	Value extends readonly [Value[0], ...infer rest]
+		? IsEqual<Value[0], Item> extends true
+			? true
+			: Includes<rest, Item>
+		: false;
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsEqual<A, B> =
+	(<G>() => G extends A ? 1 : 2) extends
+	(<G>() => G extends B ? 1 : 2)
+		? true
+		: false;
+
+/**
+Filter out keys from an object.
+
+Returns `never` if `Exclude` is strictly equal to `Key`.
+Returns `never` if `Key` extends `Exclude`.
+Returns `Key` otherwise.
+
+@example
+```
+type Filtered = Filter<'foo', 'foo'>;
+//=> never
+```
+
+@example
+```
+type Filtered = Filter<'bar', string>;
+//=> never
+```
+
+@example
+```
+type Filtered = Filter<'bar', 'foo'>;
+//=> 'bar'
+```
+
+@see {Except}
+*/
+type Filter<KeyType, ExcludeType> = IsEqual<KeyType, ExcludeType> extends true ? never : (KeyType extends ExcludeType ? never : KeyType);
+
+type ExceptOptions = {
+	/**
+	Disallow assigning non-specified properties.
+
+	Note that any omitted properties in the resulting type will be present in autocomplete as `undefined`.
+
+	@default false
+	*/
+	requireExactProps?: boolean;
+};
+
+/**
+Create a type from an object type without certain keys.
+
+We recommend setting the `requireExactProps` option to `true`.
+
+This type is a stricter version of [`Omit`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-5.html#the-omit-helper-type). The `Omit` type does not restrict the omitted keys to be keys present on the given type, while `Except` does. The benefits of a stricter type are avoiding typos and allowing the compiler to pick up on rename refactors automatically.
+
+This type was proposed to the TypeScript team, which declined it, saying they prefer that libraries implement stricter versions of the built-in types ([microsoft/TypeScript#30825](https://github.com/microsoft/TypeScript/issues/30825#issuecomment-523668235)).
+
+@example
+```
+import type {Except} from 'type-fest';
+
+type Foo = {
+	a: number;
+	b: string;
+};
+
+type FooWithoutA = Except<Foo, 'a'>;
+//=> {b: string}
+
+const fooWithoutA: FooWithoutA = {a: 1, b: '2'};
+//=> errors: 'a' does not exist in type '{ b: string; }'
+
+type FooWithoutB = Except<Foo, 'b', {requireExactProps: true}>;
+//=> {a: number} & Partial<Record<"b", never>>
+
+const fooWithoutB: FooWithoutB = {a: 1, b: '2'};
+//=> errors at 'b': Type 'string' is not assignable to type 'undefined'.
+```
+
+@category Object
+*/
+type Except<ObjectType, KeysType extends keyof ObjectType, Options extends ExceptOptions = {requireExactProps: false}> = {
+	[KeyType in keyof ObjectType as Filter<KeyType, KeysType>]: ObjectType[KeyType];
+} & (Options['requireExactProps'] extends true
+	? Partial<Record<KeysType, never>>
+	: {});
+
+/**
+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> = NonNullable<
+// Wrap in `NonNullable` to strip away the `undefined` type from the produced union.
+{
+	// 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 since the condition passes.
+		? 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$1<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$1<any> ? BuildEventDefinition$1<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 BlogTag {
     /**
      * Tag ID.
@@ -10389,18 +12859,36 @@ interface DeleteTagSignature {
      */
     (tagId: string): Promise<void>;
 }
-declare const onTagCreated$1: EventDefinition<TagCreatedEnvelope, "wix.blog.v3.tag_created">;
-declare const onTagUpdated$1: EventDefinition<TagUpdatedEnvelope, "wix.blog.v3.tag_updated">;
-declare const onTagDeleted$1: EventDefinition<TagDeletedEnvelope, "wix.blog.v3.tag_deleted">;
+declare const onTagCreated$1: EventDefinition$1<TagCreatedEnvelope, "wix.blog.v3.tag_created">;
+declare const onTagUpdated$1: EventDefinition$1<TagUpdatedEnvelope, "wix.blog.v3.tag_updated">;
+declare const onTagDeleted$1: EventDefinition$1<TagDeletedEnvelope, "wix.blog.v3.tag_deleted">;
+
+type EventDefinition<Payload = unknown, Type extends string = string> = {
+    __type: 'event-definition';
+    type: Type;
+    isDomainEvent?: boolean;
+    transformations?: (envelope: unknown) => Payload;
+    __payload: Payload;
+};
+declare function EventDefinition<Type extends string>(type: Type, isDomainEvent?: boolean, transformations?: (envelope: any) => unknown): <Payload = unknown>() => EventDefinition<Payload, Type>;
+type EventHandler<T extends EventDefinition> = (payload: T['__payload']) => void | Promise<void>;
+type BuildEventDefinition<T extends EventDefinition<any, string>> = (handler: EventHandler<T>) => void;
+
+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 function createEventModule<T extends EventDefinition<any, string>>(eventDefinition: T): BuildEventDefinition<T> & T;
 
-declare const createTag: BuildRESTFunction<typeof createTag$1> & typeof createTag$1;
-declare const getTagByLabel: BuildRESTFunction<typeof getTagByLabel$1> & typeof getTagByLabel$1;
-declare const getTag: BuildRESTFunction<typeof getTag$1> & typeof getTag$1;
-declare const getTagBySlug: BuildRESTFunction<typeof getTagBySlug$1> & typeof getTagBySlug$1;
-declare const queryTags: BuildRESTFunction<typeof queryTags$1> & typeof queryTags$1;
-declare const deleteTag: BuildRESTFunction<typeof deleteTag$1> & typeof deleteTag$1;
+declare const createTag: MaybeContext<BuildRESTFunction<typeof createTag$1> & typeof createTag$1>;
+declare const getTagByLabel: MaybeContext<BuildRESTFunction<typeof getTagByLabel$1> & typeof getTagByLabel$1>;
+declare const getTag: MaybeContext<BuildRESTFunction<typeof getTag$1> & typeof getTag$1>;
+declare const getTagBySlug: MaybeContext<BuildRESTFunction<typeof getTagBySlug$1> & typeof getTagBySlug$1>;
+declare const queryTags: MaybeContext<BuildRESTFunction<typeof queryTags$1> & typeof queryTags$1>;
+declare const deleteTag: MaybeContext<BuildRESTFunction<typeof deleteTag$1> & typeof deleteTag$1>;
 
 type _publicOnTagCreatedType = typeof onTagCreated$1;
 /**