@wix/portfolio 1.0.88 → 1.0.90

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;
+
 /** Collection is the main entity of CollectionsService */
 interface Collection {
     /**
@@ -718,7 +1084,7 @@ interface CollectionsQueryBuilder {
     find: () => Promise<CollectionsQueryResult>;
 }
 
-declare function createCollection$1(httpClient: HttpClient): CreateCollectionSignature;
+declare function createCollection$1(httpClient: HttpClient$5): CreateCollectionSignature;
 interface CreateCollectionSignature {
     /**
      * Creates a new Collection
@@ -727,7 +1093,7 @@ interface CreateCollectionSignature {
      */
     (collection: Collection): Promise<Collection & CollectionNonNullableFields>;
 }
-declare function getCollection$1(httpClient: HttpClient): GetCollectionSignature;
+declare function getCollection$1(httpClient: HttpClient$5): GetCollectionSignature;
 interface GetCollectionSignature {
     /**
      * Get a Collection by id
@@ -736,14 +1102,14 @@ interface GetCollectionSignature {
      */
     (collectionId: string, options?: GetCollectionOptions | undefined): Promise<Collection & CollectionNonNullableFields>;
 }
-declare function listCollections$1(httpClient: HttpClient): ListCollectionsSignature;
+declare function listCollections$1(httpClient: HttpClient$5): ListCollectionsSignature;
 interface ListCollectionsSignature {
     /**
      * List all Collections in portfolio
      */
     (options?: ListCollectionsOptions | undefined): Promise<ListCollectionsResponse & ListCollectionsResponseNonNullableFields>;
 }
-declare function updateCollection$1(httpClient: HttpClient): UpdateCollectionSignature;
+declare function updateCollection$1(httpClient: HttpClient$5): UpdateCollectionSignature;
 interface UpdateCollectionSignature {
     /**
      * Update a Collection, supports partial update
@@ -753,7 +1119,7 @@ interface UpdateCollectionSignature {
      */
     (_id: string | null, collection: UpdateCollection): Promise<Collection & CollectionNonNullableFields>;
 }
-declare function deleteCollection$1(httpClient: HttpClient): DeleteCollectionSignature;
+declare function deleteCollection$1(httpClient: HttpClient$5): DeleteCollectionSignature;
 interface DeleteCollectionSignature {
     /**
      * Delete a Collection
@@ -761,25 +1127,43 @@ interface DeleteCollectionSignature {
      */
     (collectionId: string): Promise<DeleteCollectionResponse & DeleteCollectionResponseNonNullableFields>;
 }
-declare function queryCollections$1(httpClient: HttpClient): QueryCollectionsSignature;
+declare function queryCollections$1(httpClient: HttpClient$5): QueryCollectionsSignature;
 interface QueryCollectionsSignature {
     /**
      * Query Collections using [WQL - Wix Query Language](https://dev.wix.com/api/rest/getting-started/api-query-language)
      */
     (options?: QueryCollectionsOptions | undefined): CollectionsQueryBuilder;
 }
-declare const onCollectionCreated$1: EventDefinition<CollectionCreatedEnvelope, "wix.portfolio.collections.v1.collection_created">;
-declare const onCollectionUpdated$1: EventDefinition<CollectionUpdatedEnvelope, "wix.portfolio.collections.v1.collection_updated">;
-declare const onCollectionDeleted$1: EventDefinition<CollectionDeletedEnvelope, "wix.portfolio.collections.v1.collection_deleted">;
+declare const onCollectionCreated$1: EventDefinition$9<CollectionCreatedEnvelope, "wix.portfolio.collections.v1.collection_created">;
+declare const onCollectionUpdated$1: EventDefinition$9<CollectionUpdatedEnvelope, "wix.portfolio.collections.v1.collection_updated">;
+declare const onCollectionDeleted$1: EventDefinition$9<CollectionDeletedEnvelope, "wix.portfolio.collections.v1.collection_deleted">;
+
+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;
+
+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$8<any, string>>(eventDefinition: T): BuildEventDefinition$8<T> & T;
 
-declare const createCollection: BuildRESTFunction<typeof createCollection$1> & typeof createCollection$1;
-declare const getCollection: BuildRESTFunction<typeof getCollection$1> & typeof getCollection$1;
-declare const listCollections: BuildRESTFunction<typeof listCollections$1> & typeof listCollections$1;
-declare const updateCollection: BuildRESTFunction<typeof updateCollection$1> & typeof updateCollection$1;
-declare const deleteCollection: BuildRESTFunction<typeof deleteCollection$1> & typeof deleteCollection$1;
-declare const queryCollections: BuildRESTFunction<typeof queryCollections$1> & typeof queryCollections$1;
+declare const createCollection: MaybeContext$5<BuildRESTFunction$5<typeof createCollection$1> & typeof createCollection$1>;
+declare const getCollection: MaybeContext$5<BuildRESTFunction$5<typeof getCollection$1> & typeof getCollection$1>;
+declare const listCollections: MaybeContext$5<BuildRESTFunction$5<typeof listCollections$1> & typeof listCollections$1>;
+declare const updateCollection: MaybeContext$5<BuildRESTFunction$5<typeof updateCollection$1> & typeof updateCollection$1>;
+declare const deleteCollection: MaybeContext$5<BuildRESTFunction$5<typeof deleteCollection$1> & typeof deleteCollection$1>;
+declare const queryCollections: MaybeContext$5<BuildRESTFunction$5<typeof queryCollections$1> & typeof queryCollections$1>;
 
 type _publicOnCollectionCreatedType = typeof onCollectionCreated$1;
 /** */
@@ -839,6 +1223,416 @@ declare namespace context$5 {
   export { type ActionEvent$5 as ActionEvent, type context$5_AdminRemoveMenuItemsResponse as AdminRemoveMenuItemsResponse, type App$2 as App, type BaseEventMetadata$3 as BaseEventMetadata, type context$5_Collection as Collection, type context$5_CollectionCreatedEnvelope as CollectionCreatedEnvelope, type context$5_CollectionDeletedEnvelope as CollectionDeletedEnvelope, type context$5_CollectionNonNullableFields as CollectionNonNullableFields, type context$5_CollectionUpdatedEnvelope as CollectionUpdatedEnvelope, type context$5_CollectionsQueryBuilder as CollectionsQueryBuilder, type context$5_CollectionsQueryResult as CollectionsQueryResult, type context$5_CreateCollectionRequest as CreateCollectionRequest, type context$5_CreateCollectionResponse as CreateCollectionResponse, type context$5_CreateCollectionResponseNonNullableFields as CreateCollectionResponseNonNullableFields, type CursorPaging$4 as CursorPaging, type Cursors$4 as Cursors, type context$5_DeleteCollectionRequest as DeleteCollectionRequest, type context$5_DeleteCollectionResponse as DeleteCollectionResponse, type context$5_DeleteCollectionResponseNonNullableFields as DeleteCollectionResponseNonNullableFields, type DomainEvent$5 as DomainEvent, type DomainEventBodyOneOf$5 as DomainEventBodyOneOf, type Empty$3 as Empty, type EntityCreatedEvent$5 as EntityCreatedEvent, type EntityDeletedEvent$5 as EntityDeletedEvent, type EntityUpdatedEvent$5 as EntityUpdatedEvent, type EventMetadata$3 as EventMetadata, type File$2 as File, type context$5_GetCollectionOptions as GetCollectionOptions, type context$5_GetCollectionRequest as GetCollectionRequest, type context$5_GetCollectionResponse as GetCollectionResponse, type context$5_GetCollectionResponseNonNullableFields as GetCollectionResponseNonNullableFields, type IdentificationData$5 as IdentificationData, type IdentificationDataIdOneOf$5 as IdentificationDataIdOneOf, type Image$3 as Image, ImageType$3 as ImageType, type InvalidateCache$2 as InvalidateCache, type InvalidateCacheGetByOneOf$2 as InvalidateCacheGetByOneOf, type Keyword$2 as Keyword, type context$5_ListCollectionsOptions as ListCollectionsOptions, type context$5_ListCollectionsRequest as ListCollectionsRequest, type context$5_ListCollectionsResponse as ListCollectionsResponse, type context$5_ListCollectionsResponseNonNullableFields as ListCollectionsResponseNonNullableFields, type MessageEnvelope$5 as MessageEnvelope, type Page$2 as Page, type Paging$3 as Paging, type PagingMetadataV2$4 as PagingMetadataV2, type Point$3 as Point, type context$5_QueryCollectionsOptions as QueryCollectionsOptions, type context$5_QueryCollectionsRequest as QueryCollectionsRequest, type context$5_QueryCollectionsResponse as QueryCollectionsResponse, type context$5_QueryCollectionsResponseNonNullableFields as QueryCollectionsResponseNonNullableFields, type QueryV2$3 as QueryV2, type QueryV2PagingMethodOneOf$3 as QueryV2PagingMethodOneOf, type RestoreInfo$5 as RestoreInfo, type SeoSchema$2 as SeoSchema, type Settings$2 as Settings, SortOrder$3 as SortOrder, type Sorting$3 as Sorting, type Tag$2 as Tag, type URI$2 as URI, type UnsharpMasking$3 as UnsharpMasking, type context$5_UpdateCollection as UpdateCollection, type context$5_UpdateCollectionRequest as UpdateCollectionRequest, type context$5_UpdateCollectionResponse as UpdateCollectionResponse, type context$5_UpdateCollectionResponseNonNullableFields as UpdateCollectionResponseNonNullableFields, WebhookIdentityType$5 as WebhookIdentityType, type context$5__publicOnCollectionCreatedType as _publicOnCollectionCreatedType, type context$5__publicOnCollectionDeletedType as _publicOnCollectionDeletedType, type context$5__publicOnCollectionUpdatedType as _publicOnCollectionUpdatedType, context$5_createCollection as createCollection, context$5_deleteCollection as deleteCollection, context$5_getCollection as getCollection, context$5_listCollections as listCollections, context$5_onCollectionCreated as onCollectionCreated, context$5_onCollectionDeleted as onCollectionDeleted, context$5_onCollectionUpdated as onCollectionUpdated, onCollectionCreated$1 as publicOnCollectionCreated, onCollectionDeleted$1 as publicOnCollectionDeleted, onCollectionUpdated$1 as publicOnCollectionUpdated, context$5_queryCollections as queryCollections, context$5_updateCollection as updateCollection };
 }
 
+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$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$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$7<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$7<any> ? BuildEventDefinition$7<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 PortfolioSettings {
     /**
      * The revision of the portfolio settings
@@ -1035,7 +1829,7 @@ interface UpdatePortfolioSettingsResponseNonNullableFields {
     updatedPortfolioSettings?: PortfolioSettingsNonNullableFields;
 }
 
-declare function createPortfolioSettings$1(httpClient: HttpClient): CreatePortfolioSettingsSignature;
+declare function createPortfolioSettings$1(httpClient: HttpClient$4): CreatePortfolioSettingsSignature;
 interface CreatePortfolioSettingsSignature {
     /**
      * Create a new portfolio settings
@@ -1044,14 +1838,14 @@ interface CreatePortfolioSettingsSignature {
      */
     (portfolioSettings: PortfolioSettings): Promise<PortfolioSettings & PortfolioSettingsNonNullableFields>;
 }
-declare function getPortfolioSettings$1(httpClient: HttpClient): GetPortfolioSettingsSignature;
+declare function getPortfolioSettings$1(httpClient: HttpClient$4): GetPortfolioSettingsSignature;
 interface GetPortfolioSettingsSignature {
     /**
      * Get the portfolio settings
      */
     (): Promise<GetPortfolioSettingsResponse & GetPortfolioSettingsResponseNonNullableFields>;
 }
-declare function updatePortfolioSettings$1(httpClient: HttpClient): UpdatePortfolioSettingsSignature;
+declare function updatePortfolioSettings$1(httpClient: HttpClient$4): UpdatePortfolioSettingsSignature;
 interface UpdatePortfolioSettingsSignature {
     /**
      * Update the portfolio settings
@@ -1060,9 +1854,9 @@ interface UpdatePortfolioSettingsSignature {
     (portfolioSettings: PortfolioSettings): Promise<UpdatePortfolioSettingsResponse & UpdatePortfolioSettingsResponseNonNullableFields>;
 }
 
-declare const createPortfolioSettings: BuildRESTFunction<typeof createPortfolioSettings$1> & typeof createPortfolioSettings$1;
-declare const getPortfolioSettings: BuildRESTFunction<typeof getPortfolioSettings$1> & typeof getPortfolioSettings$1;
-declare const updatePortfolioSettings: BuildRESTFunction<typeof updatePortfolioSettings$1> & typeof updatePortfolioSettings$1;
+declare const createPortfolioSettings: MaybeContext$4<BuildRESTFunction$4<typeof createPortfolioSettings$1> & typeof createPortfolioSettings$1>;
+declare const getPortfolioSettings: MaybeContext$4<BuildRESTFunction$4<typeof getPortfolioSettings$1> & typeof getPortfolioSettings$1>;
+declare const updatePortfolioSettings: MaybeContext$4<BuildRESTFunction$4<typeof updatePortfolioSettings$1> & typeof updatePortfolioSettings$1>;
 
 type context$4_AddItemDirection = AddItemDirection;
 declare const context$4_AddItemDirection: typeof AddItemDirection;
@@ -1089,22 +1883,432 @@ declare namespace context$4 {
   export { type ActionEvent$4 as ActionEvent, context$4_AddItemDirection as AddItemDirection, type context$4_CreatePortfolioSettingsRequest as CreatePortfolioSettingsRequest, type context$4_CreatePortfolioSettingsResponse as CreatePortfolioSettingsResponse, type context$4_CreatePortfolioSettingsResponseNonNullableFields as CreatePortfolioSettingsResponseNonNullableFields, context$4_DefaultItemName as DefaultItemName, type DomainEvent$4 as DomainEvent, type DomainEventBodyOneOf$4 as DomainEventBodyOneOf, type EntityCreatedEvent$4 as EntityCreatedEvent, type EntityDeletedEvent$4 as EntityDeletedEvent, type EntityUpdatedEvent$4 as EntityUpdatedEvent, type context$4_GetPortfolioSettingsRequest as GetPortfolioSettingsRequest, type context$4_GetPortfolioSettingsResponse as GetPortfolioSettingsResponse, type context$4_GetPortfolioSettingsResponseNonNullableFields as GetPortfolioSettingsResponseNonNullableFields, type IdentificationData$4 as IdentificationData, type IdentificationDataIdOneOf$4 as IdentificationDataIdOneOf, type context$4_MediaSettings as MediaSettings, type MessageEnvelope$4 as MessageEnvelope, type context$4_PortfolioSettings as PortfolioSettings, type context$4_PortfolioSettingsNonNullableFields as PortfolioSettingsNonNullableFields, type context$4_ProjectItemSettings as ProjectItemSettings, type RestoreInfo$4 as RestoreInfo, type context$4_SiteMenuSettings as SiteMenuSettings, type context$4_UpdatePortfolioSettingsRequest as UpdatePortfolioSettingsRequest, type context$4_UpdatePortfolioSettingsResponse as UpdatePortfolioSettingsResponse, type context$4_UpdatePortfolioSettingsResponseNonNullableFields as UpdatePortfolioSettingsResponseNonNullableFields, WebhookIdentityType$4 as WebhookIdentityType, context$4_createPortfolioSettings as createPortfolioSettings, context$4_getPortfolioSettings as getPortfolioSettings, context$4_updatePortfolioSettings as updatePortfolioSettings };
 }
 
-/** ProjectItem is the main entity of ProjectItemsService */
-interface Item extends ItemMetadataOneOf {
-    /** Information about the image. */
-    image?: Image$2;
-    /** Information about the video. */
-    video?: Video$2;
-    /**
-     * Id of the Project the items are part of
-     * Project must exist before adding items to it. You can create a project using the [ProjectService](https://dev.wix.com/docs/rest/business-solutions/portfolio/project)
-     */
-    projectId?: string | null;
-    /**
-     * Item ID.
-     * @readonly
-     */
-    _id?: string | null;
+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$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;
+
+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: {};
+}
+
+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() {}
+}
+
+type ExceptPrimitivesFromAwesome = ConditionalExcept<Awesome, Primitive>;
+//=> {run: () => void}
+```
+
+@example
+```
+import type {ConditionalExcept} from 'type-fest';
+
+interface Example {
+	a: string;
+	b: string | number;
+	c: () => void;
+	d: {};
+}
+
+type NonStringKeysOnly = ConditionalExcept<Example, string>;
+//=> {b: string | number; c: () => void; d: {}}
+```
+
+@category Object
+*/
+type ConditionalExcept$3<Base, Condition> = Except$3<
+Base,
+ConditionalKeys$3<Base, Condition>
+>;
+
+/**
+ * Descriptors are objects that describe the API of a module, and the module
+ * can either be a REST module or a host module.
+ * This type is recursive, so it can describe nested modules.
+ */
+type Descriptors$3 = RESTFunctionDescriptor$3 | AmbassadorFunctionDescriptor$3 | HostModule$3<any, any> | EventDefinition$6<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$6<any> ? BuildEventDefinition$6<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;
+
+/** ProjectItem is the main entity of ProjectItemsService */
+interface Item extends ItemMetadataOneOf {
+    /** Information about the image. */
+    image?: Image$2;
+    /** Information about the video. */
+    video?: Video$2;
+    /**
+     * Id of the Project the items are part of
+     * Project must exist before adding items to it. You can create a project using the [ProjectService](https://dev.wix.com/docs/rest/business-solutions/portfolio/project)
+     */
+    projectId?: string | null;
+    /**
+     * Item ID.
+     * @readonly
+     */
+    _id?: string | null;
     /**
      * Index that determines which position a media item is displayed in the gallery. <br />
      *
@@ -1866,7 +3070,7 @@ interface DuplicateProjectItemsOptions {
     targetProjectId: string;
 }
 
-declare function createProjectItem$1(httpClient: HttpClient): CreateProjectItemSignature;
+declare function createProjectItem$1(httpClient: HttpClient$3): CreateProjectItemSignature;
 interface CreateProjectItemSignature {
     /**
      * Creates a new ProjectItem
@@ -1875,14 +3079,14 @@ interface CreateProjectItemSignature {
      */
     (item: Item): Promise<Item & ItemNonNullableFields>;
 }
-declare function bulkCreateProjectItems$1(httpClient: HttpClient): BulkCreateProjectItemsSignature;
+declare function bulkCreateProjectItems$1(httpClient: HttpClient$3): BulkCreateProjectItemsSignature;
 interface BulkCreateProjectItemsSignature {
     /**
      * Create items in bulk
      */
     (options?: BulkCreateProjectItemsOptions | undefined): Promise<BulkCreateProjectItemsResponse & BulkCreateProjectItemsResponseNonNullableFields>;
 }
-declare function getProjectItem$1(httpClient: HttpClient): GetProjectItemSignature;
+declare function getProjectItem$1(httpClient: HttpClient$3): GetProjectItemSignature;
 interface GetProjectItemSignature {
     /**
      * Get a ProjectItem by id
@@ -1891,7 +3095,7 @@ interface GetProjectItemSignature {
      */
     (itemId: string): Promise<Item & ItemNonNullableFields>;
 }
-declare function listProjectItems$1(httpClient: HttpClient): ListProjectItemsSignature;
+declare function listProjectItems$1(httpClient: HttpClient$3): ListProjectItemsSignature;
 interface ListProjectItemsSignature {
     /**
      * List all items in project
@@ -1899,7 +3103,7 @@ interface ListProjectItemsSignature {
      */
     (projectId: string, options?: ListProjectItemsOptions | undefined): Promise<ListProjectItemsResponse & ListProjectItemsResponseNonNullableFields>;
 }
-declare function updateProjectItem$1(httpClient: HttpClient): UpdateProjectItemSignature;
+declare function updateProjectItem$1(httpClient: HttpClient$3): UpdateProjectItemSignature;
 interface UpdateProjectItemSignature {
     /**
      * Update a ProjectItem, supports partial update
@@ -1908,14 +3112,14 @@ interface UpdateProjectItemSignature {
      */
     (_id: string | null, item: UpdateProjectItem): Promise<Item & ItemNonNullableFields>;
 }
-declare function bulkUpdateProjectItems$1(httpClient: HttpClient): BulkUpdateProjectItemsSignature;
+declare function bulkUpdateProjectItems$1(httpClient: HttpClient$3): BulkUpdateProjectItemsSignature;
 interface BulkUpdateProjectItemsSignature {
     /**
      * Update ProjectItems in bulk
      */
     (options?: BulkUpdateProjectItemsOptions | undefined): Promise<BulkUpdateProjectItemsResponse & BulkUpdateProjectItemsResponseNonNullableFields>;
 }
-declare function deleteProjectItem$1(httpClient: HttpClient): DeleteProjectItemSignature;
+declare function deleteProjectItem$1(httpClient: HttpClient$3): DeleteProjectItemSignature;
 interface DeleteProjectItemSignature {
     /**
      * Delete a ProjectItem
@@ -1923,14 +3127,14 @@ interface DeleteProjectItemSignature {
      */
     (itemId: string): Promise<DeleteProjectItemResponse & DeleteProjectItemResponseNonNullableFields>;
 }
-declare function bulkDeleteProjectItems$1(httpClient: HttpClient): BulkDeleteProjectItemsSignature;
+declare function bulkDeleteProjectItems$1(httpClient: HttpClient$3): BulkDeleteProjectItemsSignature;
 interface BulkDeleteProjectItemsSignature {
     /**
      * Delete items in bulk
      */
     (options: BulkDeleteProjectItemsOptions): Promise<BulkDeleteProjectItemsResponse & BulkDeleteProjectItemsResponseNonNullableFields>;
 }
-declare function duplicateProjectItems$1(httpClient: HttpClient): DuplicateProjectItemsSignature;
+declare function duplicateProjectItems$1(httpClient: HttpClient$3): DuplicateProjectItemsSignature;
 interface DuplicateProjectItemsSignature {
     /**
      * Given an 'origin' Project and 'target' Project, copy all ProjectItems in 'origin' Project to 'target' Project.
@@ -1938,21 +3142,39 @@ interface DuplicateProjectItemsSignature {
      */
     (originProjectId: string, options: DuplicateProjectItemsOptions): Promise<DuplicateProjectItemsResponse & DuplicateProjectItemsResponseNonNullableFields>;
 }
-declare const onProjectItemCreated$1: EventDefinition<ProjectItemCreatedEnvelope, "wix.portfolio.project_items.v1.project_item_created">;
-declare const onProjectItemUpdated$1: EventDefinition<ProjectItemUpdatedEnvelope, "wix.portfolio.project_items.v1.project_item_updated">;
-declare const onProjectItemDeleted$1: EventDefinition<ProjectItemDeletedEnvelope, "wix.portfolio.project_items.v1.project_item_deleted">;
+declare const onProjectItemCreated$1: EventDefinition$6<ProjectItemCreatedEnvelope, "wix.portfolio.project_items.v1.project_item_created">;
+declare const onProjectItemUpdated$1: EventDefinition$6<ProjectItemUpdatedEnvelope, "wix.portfolio.project_items.v1.project_item_updated">;
+declare const onProjectItemDeleted$1: EventDefinition$6<ProjectItemDeletedEnvelope, "wix.portfolio.project_items.v1.project_item_deleted">;
+
+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;
+
+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<any, string>>(eventDefinition: T): BuildEventDefinition<T> & T;
+declare function createEventModule$2<T extends EventDefinition$5<any, string>>(eventDefinition: T): BuildEventDefinition$5<T> & T;
 
-declare const createProjectItem: BuildRESTFunction<typeof createProjectItem$1> & typeof createProjectItem$1;
-declare const bulkCreateProjectItems: BuildRESTFunction<typeof bulkCreateProjectItems$1> & typeof bulkCreateProjectItems$1;
-declare const getProjectItem: BuildRESTFunction<typeof getProjectItem$1> & typeof getProjectItem$1;
-declare const listProjectItems: BuildRESTFunction<typeof listProjectItems$1> & typeof listProjectItems$1;
-declare const updateProjectItem: BuildRESTFunction<typeof updateProjectItem$1> & typeof updateProjectItem$1;
-declare const bulkUpdateProjectItems: BuildRESTFunction<typeof bulkUpdateProjectItems$1> & typeof bulkUpdateProjectItems$1;
-declare const deleteProjectItem: BuildRESTFunction<typeof deleteProjectItem$1> & typeof deleteProjectItem$1;
-declare const bulkDeleteProjectItems: BuildRESTFunction<typeof bulkDeleteProjectItems$1> & typeof bulkDeleteProjectItems$1;
-declare const duplicateProjectItems: BuildRESTFunction<typeof duplicateProjectItems$1> & typeof duplicateProjectItems$1;
+declare const createProjectItem: MaybeContext$3<BuildRESTFunction$3<typeof createProjectItem$1> & typeof createProjectItem$1>;
+declare const bulkCreateProjectItems: MaybeContext$3<BuildRESTFunction$3<typeof bulkCreateProjectItems$1> & typeof bulkCreateProjectItems$1>;
+declare const getProjectItem: MaybeContext$3<BuildRESTFunction$3<typeof getProjectItem$1> & typeof getProjectItem$1>;
+declare const listProjectItems: MaybeContext$3<BuildRESTFunction$3<typeof listProjectItems$1> & typeof listProjectItems$1>;
+declare const updateProjectItem: MaybeContext$3<BuildRESTFunction$3<typeof updateProjectItem$1> & typeof updateProjectItem$1>;
+declare const bulkUpdateProjectItems: MaybeContext$3<BuildRESTFunction$3<typeof bulkUpdateProjectItems$1> & typeof bulkUpdateProjectItems$1>;
+declare const deleteProjectItem: MaybeContext$3<BuildRESTFunction$3<typeof deleteProjectItem$1> & typeof deleteProjectItem$1>;
+declare const bulkDeleteProjectItems: MaybeContext$3<BuildRESTFunction$3<typeof bulkDeleteProjectItems$1> & typeof bulkDeleteProjectItems$1>;
+declare const duplicateProjectItems: MaybeContext$3<BuildRESTFunction$3<typeof duplicateProjectItems$1> & typeof duplicateProjectItems$1>;
 
 type _publicOnProjectItemCreatedType = typeof onProjectItemCreated$1;
 /** */
@@ -2039,72 +3261,477 @@ declare namespace context$3 {
   export { type ActionEvent$3 as ActionEvent, type App$1 as App, type ApplicationError$1 as ApplicationError, type BaseEventMetadata$2 as BaseEventMetadata, type BulkActionMetadata$1 as BulkActionMetadata, type context$3_BulkCreateProjectItemResult as BulkCreateProjectItemResult, type context$3_BulkCreateProjectItemsOptions as BulkCreateProjectItemsOptions, type context$3_BulkCreateProjectItemsRequest as BulkCreateProjectItemsRequest, type context$3_BulkCreateProjectItemsResponse as BulkCreateProjectItemsResponse, type context$3_BulkCreateProjectItemsResponseNonNullableFields as BulkCreateProjectItemsResponseNonNullableFields, type context$3_BulkDeleteProjectItemResult as BulkDeleteProjectItemResult, type context$3_BulkDeleteProjectItemsOptions as BulkDeleteProjectItemsOptions, type context$3_BulkDeleteProjectItemsRequest as BulkDeleteProjectItemsRequest, type context$3_BulkDeleteProjectItemsResponse as BulkDeleteProjectItemsResponse, type context$3_BulkDeleteProjectItemsResponseNonNullableFields as BulkDeleteProjectItemsResponseNonNullableFields, type context$3_BulkUpdateProjectItemResult as BulkUpdateProjectItemResult, type context$3_BulkUpdateProjectItemsOptions as BulkUpdateProjectItemsOptions, type context$3_BulkUpdateProjectItemsRequest as BulkUpdateProjectItemsRequest, type context$3_BulkUpdateProjectItemsResponse as BulkUpdateProjectItemsResponse, type context$3_BulkUpdateProjectItemsResponseNonNullableFields as BulkUpdateProjectItemsResponseNonNullableFields, type context$3_CreateProjectGalleryRequest as CreateProjectGalleryRequest, type context$3_CreateProjectGalleryResponse as CreateProjectGalleryResponse, type context$3_CreateProjectItemRequest as CreateProjectItemRequest, type context$3_CreateProjectItemResponse as CreateProjectItemResponse, type context$3_CreateProjectItemResponseNonNullableFields as CreateProjectItemResponseNonNullableFields, type CursorPaging$3 as CursorPaging, type Cursors$3 as Cursors, type context$3_DeleteProjectItemRequest as DeleteProjectItemRequest, type context$3_DeleteProjectItemResponse as DeleteProjectItemResponse, type context$3_DeleteProjectItemResponseNonNullableFields as DeleteProjectItemResponseNonNullableFields, type DeletedProjectRestored$1 as DeletedProjectRestored, type DomainEvent$3 as DomainEvent, type DomainEventBodyOneOf$3 as DomainEventBodyOneOf, type context$3_DuplicateProjectItemsOptions as DuplicateProjectItemsOptions, type context$3_DuplicateProjectItemsRequest as DuplicateProjectItemsRequest, type context$3_DuplicateProjectItemsResponse as DuplicateProjectItemsResponse, type context$3_DuplicateProjectItemsResponseNonNullableFields as DuplicateProjectItemsResponseNonNullableFields, type Empty$2 as Empty, type EntityCreatedEvent$3 as EntityCreatedEvent, type EntityDeletedEvent$3 as EntityDeletedEvent, type EntityUpdatedEvent$3 as EntityUpdatedEvent, type EventMetadata$2 as EventMetadata, type File$1 as File, type context$3_GenerateTokenForProjectItemsRequest as GenerateTokenForProjectItemsRequest, type context$3_GenerateTokenForProjectItemsResponse as GenerateTokenForProjectItemsResponse, type context$3_GetProjectItemRequest as GetProjectItemRequest, type context$3_GetProjectItemResponse as GetProjectItemResponse, type context$3_GetProjectItemResponseNonNullableFields as GetProjectItemResponseNonNullableFields, type IdentificationData$3 as IdentificationData, type IdentificationDataIdOneOf$3 as IdentificationDataIdOneOf, type Image$2 as Image, ImageType$2 as ImageType, type InvalidateCache$1 as InvalidateCache, type InvalidateCacheGetByOneOf$1 as InvalidateCacheGetByOneOf, type context$3_Item as Item, type ItemMetadata$1 as ItemMetadata, type context$3_ItemMetadataOneOf as ItemMetadataOneOf, type context$3_ItemNonNullableFields as ItemNonNullableFields, type context$3_Link as Link, type context$3_ListProjectItemsOptions as ListProjectItemsOptions, type context$3_ListProjectItemsRequest as ListProjectItemsRequest, type context$3_ListProjectItemsResponse as ListProjectItemsResponse, type context$3_ListProjectItemsResponseNonNullableFields as ListProjectItemsResponseNonNullableFields, type context$3_MaskedItem as MaskedItem, type MessageEnvelope$3 as MessageEnvelope, type Page$1 as Page, type Paging$2 as Paging, type PagingMetadataV2$3 as PagingMetadataV2, type Point$2 as Point, type context$3_ProjectItemCreatedEnvelope as ProjectItemCreatedEnvelope, type context$3_ProjectItemDeletedEnvelope as ProjectItemDeletedEnvelope, type context$3_ProjectItemMediaToken as ProjectItemMediaToken, type context$3_ProjectItemUpdatedEnvelope as ProjectItemUpdatedEnvelope, type context$3_QueryProjectItemsRequest as QueryProjectItemsRequest, type context$3_QueryProjectItemsResponse as QueryProjectItemsResponse, type QueryV2$2 as QueryV2, type QueryV2PagingMethodOneOf$2 as QueryV2PagingMethodOneOf, type RestoreInfo$3 as RestoreInfo, SortOrder$2 as SortOrder, type Sorting$2 as Sorting, type context$3_Tags as Tags, context$3_Type as Type, type URI$1 as URI, type UnsharpMasking$2 as UnsharpMasking, type context$3_UpdateProjectItem as UpdateProjectItem, type context$3_UpdateProjectItemRequest as UpdateProjectItemRequest, type context$3_UpdateProjectItemResponse as UpdateProjectItemResponse, type context$3_UpdateProjectItemResponseNonNullableFields as UpdateProjectItemResponseNonNullableFields, type Video$2 as Video, type VideoResolution$2 as VideoResolution, WebhookIdentityType$3 as WebhookIdentityType, type context$3__publicOnProjectItemCreatedType as _publicOnProjectItemCreatedType, type context$3__publicOnProjectItemDeletedType as _publicOnProjectItemDeletedType, type context$3__publicOnProjectItemUpdatedType as _publicOnProjectItemUpdatedType, context$3_bulkCreateProjectItems as bulkCreateProjectItems, context$3_bulkDeleteProjectItems as bulkDeleteProjectItems, context$3_bulkUpdateProjectItems as bulkUpdateProjectItems, context$3_createProjectItem as createProjectItem, context$3_deleteProjectItem as deleteProjectItem, context$3_duplicateProjectItems as duplicateProjectItems, context$3_getProjectItem as getProjectItem, context$3_listProjectItems as listProjectItems, context$3_onProjectItemCreated as onProjectItemCreated, context$3_onProjectItemDeleted as onProjectItemDeleted, context$3_onProjectItemUpdated as onProjectItemUpdated, onProjectItemCreated$1 as publicOnProjectItemCreated, onProjectItemDeleted$1 as publicOnProjectItemDeleted, onProjectItemUpdated$1 as publicOnProjectItemUpdated, context$3_updateProjectItem as updateProjectItem };
 }
 
-/** Project is the main entity of ProjectsService */
-interface Project$1 extends ProjectCoverOneOf$1 {
-    /** project's cover photo */
-    coverImage?: Image$1;
-    /** project's cover video */
-    coverVideo?: Video$1;
-    /**
-     * Project ID
-     * @readonly
-     */
-    _id?: string | null;
-    /**
-     * Represents the current state of an item. Each time the item is modified, its `revision` changes. for an update operation to succeed, you MUST pass the latest revision
-     * @readonly
-     */
-    revision?: string | null;
-    title?: string | null;
-    description?: string | null;
-    /** indicates if the project should be hidden from Portfolio */
-    hidden?: boolean | null;
-    /** Collections must exist to be added to a project. Can be created/updated/deleted using [Collection Service](https://dev.wix.com/docs/rest/business-solutions/portfolio/collection) */
-    collectionIds?: string[];
-    /** Custom project details */
-    details?: ProjectDetail$1[];
-    /** Project's slug */
-    slug?: string | null;
-    /**
-     * Represents the time this Project was created
-     * @readonly
-     */
-    _createdDate?: Date;
-    /**
-     * Represents the time this Project was last updated
-     * @readonly
-     */
-    _updatedDate?: Date;
-    /**
-     * Url and relative url of Project - in order to receive this field in READ requests you will need to pass the `include_page_url` field as part of request
-     * @readonly
-     */
-    url?: string;
-    /** SEO data for the project */
-    seoData?: SeoSchema$1;
-    /**
-     * indicates if the project is synced from external platform (via integration page) and therefore will be updated from the external platform on daily basis
-     * @readonly
-     */
-    syncedProject?: boolean | null;
-}
-/** @oneof */
-interface ProjectCoverOneOf$1 {
-    /** project's cover photo */
-    coverImage?: Image$1;
-    /** project's cover video */
-    coverVideo?: Video$1;
+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;
 }
-interface Image$1 {
-    /** Image info - Wix Media Image. */
-    imageInfo?: string;
-    /** Focal point of the image. */
-    focalPoint?: Point$1;
+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$4<Payload = unknown, Type extends string = string> = {
+    __type: 'event-definition';
+    type: Type;
+    isDomainEvent?: boolean;
+    transformations?: (envelope: unknown) => Payload;
+    __payload: Payload;
+};
+declare function EventDefinition$4<Type extends string>(type: Type, isDomainEvent?: boolean, transformations?: (envelope: any) => unknown): <Payload = unknown>() => EventDefinition$4<Payload, Type>;
+type EventHandler$4<T extends EventDefinition$4> = (payload: T['__payload']) => void | Promise<void>;
+type BuildEventDefinition$4<T extends EventDefinition$4<any, string>> = (handler: EventHandler$4<T>) => void;
+
+type ServicePluginMethodInput$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 enum ImageType$1 {
-    UNDEFINED = "UNDEFINED",
-    WIX_MEDIA = "WIX_MEDIA",
-    EXTERNAL = "EXTERNAL"
+
+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$4<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$4<any> ? BuildEventDefinition$4<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;
+
+/** Project is the main entity of ProjectsService */
+interface Project$1 extends ProjectCoverOneOf$1 {
+    /** project's cover photo */
+    coverImage?: Image$1;
+    /** project's cover video */
+    coverVideo?: Video$1;
+    /**
+     * Project ID
+     * @readonly
+     */
+    _id?: string | null;
+    /**
+     * Represents the current state of an item. Each time the item is modified, its `revision` changes. for an update operation to succeed, you MUST pass the latest revision
+     * @readonly
+     */
+    revision?: string | null;
+    title?: string | null;
+    description?: string | null;
+    /** indicates if the project should be hidden from Portfolio */
+    hidden?: boolean | null;
+    /** Collections must exist to be added to a project. Can be created/updated/deleted using [Collection Service](https://dev.wix.com/docs/rest/business-solutions/portfolio/collection) */
+    collectionIds?: string[];
+    /** Custom project details */
+    details?: ProjectDetail$1[];
+    /** Project's slug */
+    slug?: string | null;
+    /**
+     * Represents the time this Project was created
+     * @readonly
+     */
+    _createdDate?: Date;
+    /**
+     * Represents the time this Project was last updated
+     * @readonly
+     */
+    _updatedDate?: Date;
+    /**
+     * Url and relative url of Project - in order to receive this field in READ requests you will need to pass the `include_page_url` field as part of request
+     * @readonly
+     */
+    url?: string;
+    /** SEO data for the project */
+    seoData?: SeoSchema$1;
+}
+/** @oneof */
+interface ProjectCoverOneOf$1 {
+    /** project's cover photo */
+    coverImage?: Image$1;
+    /** project's cover video */
+    coverVideo?: Video$1;
+}
+interface Image$1 {
+    /** Image info - Wix Media Image. */
+    imageInfo?: string;
+    /** Focal point of the image. */
+    focalPoint?: Point$1;
+}
+declare enum ImageType$1 {
+    UNDEFINED = "UNDEFINED",
+    WIX_MEDIA = "WIX_MEDIA",
+    EXTERNAL = "EXTERNAL"
 }
 interface Point$1 {
     /** X-coordinate of the focal point. */
@@ -3180,11 +4807,6 @@ interface UpdateProject {
     url?: string;
     /** SEO data for the project */
     seoData?: SeoSchema$1;
-    /**
-     * indicates if the project is synced from external platform (via integration page) and therefore will be updated from the external platform on daily basis
-     * @readonly
-     */
-    syncedProject?: boolean | null;
 }
 interface BulkUpdateProjectsOptions {
     /** projects to be updated. */
@@ -3289,14 +4911,14 @@ interface QueryProjectsWithCollectionInfoOptions {
     includePageUrl?: boolean | null;
 }
 
-declare function getProjectPageData$1(httpClient: HttpClient): GetProjectPageDataSignature;
+declare function getProjectPageData$1(httpClient: HttpClient$2): GetProjectPageDataSignature;
 interface GetProjectPageDataSignature {
     /**
      * Get project data for a specific project
      */
     (identifiers: GetProjectPageDataIdentifiers): Promise<GetProjectPageDataResponse & GetProjectPageDataResponseNonNullableFields>;
 }
-declare function createProject$1(httpClient: HttpClient): CreateProjectSignature;
+declare function createProject$1(httpClient: HttpClient$2): CreateProjectSignature;
 interface CreateProjectSignature {
     /**
      * Creates a new Project
@@ -3305,7 +4927,7 @@ interface CreateProjectSignature {
      */
     (project: Project$1): Promise<Project$1 & ProjectNonNullableFields$1>;
 }
-declare function getProject$1(httpClient: HttpClient): GetProjectSignature;
+declare function getProject$1(httpClient: HttpClient$2): GetProjectSignature;
 interface GetProjectSignature {
     /**
      * Get a Project by id
@@ -3314,14 +4936,14 @@ interface GetProjectSignature {
      */
     (projectId: string, options?: GetProjectOptions | undefined): Promise<Project$1 & ProjectNonNullableFields$1>;
 }
-declare function listProjects$1(httpClient: HttpClient): ListProjectsSignature;
+declare function listProjects$1(httpClient: HttpClient$2): ListProjectsSignature;
 interface ListProjectsSignature {
     /**
      * List all projects in portfolio by creation date
      */
     (options?: ListProjectsOptions | undefined): Promise<ListProjectsResponse & ListProjectsResponseNonNullableFields>;
 }
-declare function updateProject$1(httpClient: HttpClient): UpdateProjectSignature;
+declare function updateProject$1(httpClient: HttpClient$2): UpdateProjectSignature;
 interface UpdateProjectSignature {
     /**
      * Update a Project, supports partial update
@@ -3331,14 +4953,14 @@ interface UpdateProjectSignature {
      */
     (_id: string | null, project: UpdateProject): Promise<Project$1 & ProjectNonNullableFields$1>;
 }
-declare function bulkUpdateProjects$1(httpClient: HttpClient): BulkUpdateProjectsSignature;
+declare function bulkUpdateProjects$1(httpClient: HttpClient$2): BulkUpdateProjectsSignature;
 interface BulkUpdateProjectsSignature {
     /**
      * Update Projects in bulk
      */
     (options?: BulkUpdateProjectsOptions | undefined): Promise<BulkUpdateProjectsResponse & BulkUpdateProjectsResponseNonNullableFields>;
 }
-declare function deleteProject$1(httpClient: HttpClient): DeleteProjectSignature;
+declare function deleteProject$1(httpClient: HttpClient$2): DeleteProjectSignature;
 interface DeleteProjectSignature {
     /**
      * Delete a Project
@@ -3346,14 +4968,14 @@ interface DeleteProjectSignature {
      */
     (projectId: string): Promise<DeleteProjectResponse & DeleteProjectResponseNonNullableFields>;
 }
-declare function queryProjects$1(httpClient: HttpClient): QueryProjectsSignature;
+declare function queryProjects$1(httpClient: HttpClient$2): QueryProjectsSignature;
 interface QueryProjectsSignature {
     /**
      * Query Projects using [WQL - Wix Query Language](https://dev.wix.com/api/rest/getting-started/api-query-language)
      */
     (options?: QueryProjectsOptions | undefined): ProjectsQueryBuilder;
 }
-declare function updateProjectOrderInCollection$3(httpClient: HttpClient): UpdateProjectOrderInCollectionSignature$1;
+declare function updateProjectOrderInCollection$3(httpClient: HttpClient$2): UpdateProjectOrderInCollectionSignature$1;
 interface UpdateProjectOrderInCollectionSignature$1 {
     /**
      * Deprecated - please use ProjectsInCollectionsService.UpdateProjectOrderInCollection instead
@@ -3363,7 +4985,7 @@ interface UpdateProjectOrderInCollectionSignature$1 {
      */
     (identifiers: UpdateProjectOrderInCollectionIdentifiers$1, sortOrder: number | null): Promise<UpdateProjectOrderInCollectionResponse$1 & UpdateProjectOrderInCollectionResponseNonNullableFields$1>;
 }
-declare function queryProjectsWithCollectionInfo$1(httpClient: HttpClient): QueryProjectsWithCollectionInfoSignature;
+declare function queryProjectsWithCollectionInfo$1(httpClient: HttpClient$2): QueryProjectsWithCollectionInfoSignature;
 interface QueryProjectsWithCollectionInfoSignature {
     /**
      * Deprecated - please use ProjectsInCollectionsService.QueryProjectsInCollections instead
@@ -3373,22 +4995,40 @@ interface QueryProjectsWithCollectionInfoSignature {
      */
     (query: QueryV2$1, options?: QueryProjectsWithCollectionInfoOptions | undefined): Promise<QueryProjectWithCollectionInfoResponse & QueryProjectWithCollectionInfoResponseNonNullableFields>;
 }
-declare const onProjectCreated$1: EventDefinition<ProjectCreatedEnvelope, "wix.portfolio.projects.v1.project_created">;
-declare const onProjectUpdated$1: EventDefinition<ProjectUpdatedEnvelope, "wix.portfolio.projects.v1.project_updated">;
-declare const onProjectDeleted$1: EventDefinition<ProjectDeletedEnvelope, "wix.portfolio.projects.v1.project_deleted">;
+declare const onProjectCreated$1: EventDefinition$4<ProjectCreatedEnvelope, "wix.portfolio.projects.v1.project_created">;
+declare const onProjectUpdated$1: EventDefinition$4<ProjectUpdatedEnvelope, "wix.portfolio.projects.v1.project_updated">;
+declare const onProjectDeleted$1: EventDefinition$4<ProjectDeletedEnvelope, "wix.portfolio.projects.v1.project_deleted">;
 
-declare function createEventModule$1<T extends EventDefinition<any, string>>(eventDefinition: T): BuildEventDefinition<T> & T;
+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;
 
-declare const getProjectPageData: BuildRESTFunction<typeof getProjectPageData$1> & typeof getProjectPageData$1;
-declare const createProject: BuildRESTFunction<typeof createProject$1> & typeof createProject$1;
-declare const getProject: BuildRESTFunction<typeof getProject$1> & typeof getProject$1;
-declare const listProjects: BuildRESTFunction<typeof listProjects$1> & typeof listProjects$1;
-declare const updateProject: BuildRESTFunction<typeof updateProject$1> & typeof updateProject$1;
-declare const bulkUpdateProjects: BuildRESTFunction<typeof bulkUpdateProjects$1> & typeof bulkUpdateProjects$1;
-declare const deleteProject: BuildRESTFunction<typeof deleteProject$1> & typeof deleteProject$1;
-declare const queryProjects: BuildRESTFunction<typeof queryProjects$1> & typeof queryProjects$1;
-declare const updateProjectOrderInCollection$2: BuildRESTFunction<typeof updateProjectOrderInCollection$3> & typeof updateProjectOrderInCollection$3;
-declare const queryProjectsWithCollectionInfo: BuildRESTFunction<typeof queryProjectsWithCollectionInfo$1> & typeof queryProjectsWithCollectionInfo$1;
+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$3<any, string>>(eventDefinition: T): BuildEventDefinition$3<T> & T;
+
+declare const getProjectPageData: MaybeContext$2<BuildRESTFunction$2<typeof getProjectPageData$1> & typeof getProjectPageData$1>;
+declare const createProject: MaybeContext$2<BuildRESTFunction$2<typeof createProject$1> & typeof createProject$1>;
+declare const getProject: MaybeContext$2<BuildRESTFunction$2<typeof getProject$1> & typeof getProject$1>;
+declare const listProjects: MaybeContext$2<BuildRESTFunction$2<typeof listProjects$1> & typeof listProjects$1>;
+declare const updateProject: MaybeContext$2<BuildRESTFunction$2<typeof updateProject$1> & typeof updateProject$1>;
+declare const bulkUpdateProjects: MaybeContext$2<BuildRESTFunction$2<typeof bulkUpdateProjects$1> & typeof bulkUpdateProjects$1>;
+declare const deleteProject: MaybeContext$2<BuildRESTFunction$2<typeof deleteProject$1> & typeof deleteProject$1>;
+declare const queryProjects: MaybeContext$2<BuildRESTFunction$2<typeof queryProjects$1> & typeof queryProjects$1>;
+declare const updateProjectOrderInCollection$2: MaybeContext$2<BuildRESTFunction$2<typeof updateProjectOrderInCollection$3> & typeof updateProjectOrderInCollection$3>;
+declare const queryProjectsWithCollectionInfo: MaybeContext$2<BuildRESTFunction$2<typeof queryProjectsWithCollectionInfo$1> & typeof queryProjectsWithCollectionInfo$1>;
 
 type _publicOnProjectCreatedType = typeof onProjectCreated$1;
 /** */
@@ -3479,6 +5119,416 @@ declare namespace context$2 {
   export { type ActionEvent$2 as ActionEvent, type context$2_App as App, type context$2_ApplicationError as ApplicationError, type Asset$1 as Asset, type BaseEventMetadata$1 as BaseEventMetadata, type context$2_BulkActionMetadata as BulkActionMetadata, type context$2_BulkUpdateProjectsOptions as BulkUpdateProjectsOptions, type context$2_BulkUpdateProjectsRequest as BulkUpdateProjectsRequest, type context$2_BulkUpdateProjectsResponse as BulkUpdateProjectsResponse, type context$2_BulkUpdateProjectsResponseNonNullableFields as BulkUpdateProjectsResponseNonNullableFields, type context$2_BulkUpdateProjectsResult as BulkUpdateProjectsResult, type context$2_CreateNewPortfolioAppRequest as CreateNewPortfolioAppRequest, type context$2_CreateNewPortfolioAppResponse as CreateNewPortfolioAppResponse, type context$2_CreateProjectRequest as CreateProjectRequest, type context$2_CreateProjectResponse as CreateProjectResponse, type context$2_CreateProjectResponseNonNullableFields as CreateProjectResponseNonNullableFields, type CursorPaging$2 as CursorPaging, type Cursors$2 as Cursors, type DeleteContext$1 as DeleteContext, type context$2_DeleteProjectRequest as DeleteProjectRequest, type context$2_DeleteProjectResponse as DeleteProjectResponse, type context$2_DeleteProjectResponseNonNullableFields as DeleteProjectResponseNonNullableFields, DeleteStatus$1 as DeleteStatus, type context$2_DeletedProjectRestored as DeletedProjectRestored, type DetailsLink$1 as DetailsLink, type DomainEvent$2 as DomainEvent, type DomainEventBodyOneOf$2 as DomainEventBodyOneOf, type Empty$1 as Empty, type EntityCreatedEvent$2 as EntityCreatedEvent, type EntityDeletedEvent$2 as EntityDeletedEvent, type EntityUpdatedEvent$2 as EntityUpdatedEvent, type EventMetadata$1 as EventMetadata, type context$2_File as File, type context$2_GetProjectOptions as GetProjectOptions, type context$2_GetProjectPageDataIdentifiers as GetProjectPageDataIdentifiers, type context$2_GetProjectPageDataRequest as GetProjectPageDataRequest, type context$2_GetProjectPageDataResponse as GetProjectPageDataResponse, type context$2_GetProjectPageDataResponseNonNullableFields as GetProjectPageDataResponseNonNullableFields, type context$2_GetProjectRequest as GetProjectRequest, type context$2_GetProjectResponse as GetProjectResponse, type context$2_GetProjectResponseNonNullableFields as GetProjectResponseNonNullableFields, type IdentificationData$2 as IdentificationData, type IdentificationDataIdOneOf$2 as IdentificationDataIdOneOf, type Image$1 as Image, ImageType$1 as ImageType, type context$2_InvalidateCache as InvalidateCache, type context$2_InvalidateCacheGetByOneOf as InvalidateCacheGetByOneOf, type context$2_ItemMetadata as ItemMetadata, type Keyword$1 as Keyword, type context$2_ListProjectsOptions as ListProjectsOptions, type context$2_ListProjectsRequest as ListProjectsRequest, type context$2_ListProjectsResponse as ListProjectsResponse, type context$2_ListProjectsResponseNonNullableFields as ListProjectsResponseNonNullableFields, type context$2_MaskedProject as MaskedProject, type context$2_MenuSettingUpdatedEvent as MenuSettingUpdatedEvent, type MessageEnvelope$2 as MessageEnvelope, type MetaSiteSpecialEvent$1 as MetaSiteSpecialEvent, type MetaSiteSpecialEventPayloadOneOf$1 as MetaSiteSpecialEventPayloadOneOf, Namespace$1 as Namespace, type NamespaceChanged$1 as NamespaceChanged, type context$2_Page as Page, type Paging$1 as Paging, type PagingMetadataV2$2 as PagingMetadataV2, type Point$1 as Point, type Project$1 as Project, type ProjectCoverOneOf$1 as ProjectCoverOneOf, type context$2_ProjectCreatedEnvelope as ProjectCreatedEnvelope, type context$2_ProjectDeletedEnvelope as ProjectDeletedEnvelope, type ProjectDetail$1 as ProjectDetail, type ProjectDetailValueOneOf$1 as ProjectDetailValueOneOf, type ProjectInCollection$1 as ProjectInCollection, type ProjectNonNullableFields$1 as ProjectNonNullableFields, type context$2_ProjectSlug as ProjectSlug, type ProjectSource$1 as ProjectSource, type context$2_ProjectUpdatedEnvelope as ProjectUpdatedEnvelope, type context$2_ProjectsQueryBuilder as ProjectsQueryBuilder, type context$2_ProjectsQueryResult as ProjectsQueryResult, type context$2_QueryProjectWithCollectionInfoRequest as QueryProjectWithCollectionInfoRequest, type context$2_QueryProjectWithCollectionInfoResponse as QueryProjectWithCollectionInfoResponse, type context$2_QueryProjectWithCollectionInfoResponseNonNullableFields as QueryProjectWithCollectionInfoResponseNonNullableFields, type context$2_QueryProjectsOptions as QueryProjectsOptions, type context$2_QueryProjectsRequest as QueryProjectsRequest, type context$2_QueryProjectsResponse as QueryProjectsResponse, type context$2_QueryProjectsResponseNonNullableFields as QueryProjectsResponseNonNullableFields, type context$2_QueryProjectsWithCollectionInfoOptions as QueryProjectsWithCollectionInfoOptions, type QueryV2$1 as QueryV2, type QueryV2PagingMethodOneOf$1 as QueryV2PagingMethodOneOf, type RestoreInfo$2 as RestoreInfo, type context$2_RestoreProjectFromTrashBinRequest as RestoreProjectFromTrashBinRequest, type context$2_RestoreProjectFromTrashBinResponse as RestoreProjectFromTrashBinResponse, type SeoSchema$1 as SeoSchema, type ServiceProvisioned$1 as ServiceProvisioned, type ServiceRemoved$1 as ServiceRemoved, type Settings$1 as Settings, type SiteCreated$1 as SiteCreated, SiteCreatedContext$1 as SiteCreatedContext, type SiteDeleted$1 as SiteDeleted, type SiteHardDeleted$1 as SiteHardDeleted, type SiteMarkedAsTemplate$1 as SiteMarkedAsTemplate, type SiteMarkedAsWixSite$1 as SiteMarkedAsWixSite, type SitePublished$1 as SitePublished, type SiteRenamed$1 as SiteRenamed, type SiteTransferred$1 as SiteTransferred, type SiteUndeleted$1 as SiteUndeleted, type SiteUnpublished$1 as SiteUnpublished, SortOrder$1 as SortOrder, type Sorting$1 as Sorting, State$1 as State, type StudioAssigned$1 as StudioAssigned, type StudioUnassigned$1 as StudioUnassigned, type context$2_SyncProjectWithCollectionMappings as SyncProjectWithCollectionMappings, SyncStatus$2 as SyncStatus, type Tag$1 as Tag, type context$2_URI as URI, type UnsharpMasking$1 as UnsharpMasking, type context$2_UpdateProject as UpdateProject, type UpdateProjectOrderInCollectionIdentifiers$1 as UpdateProjectOrderInCollectionIdentifiers, type UpdateProjectOrderInCollectionRequest$1 as UpdateProjectOrderInCollectionRequest, type UpdateProjectOrderInCollectionResponse$1 as UpdateProjectOrderInCollectionResponse, type UpdateProjectOrderInCollectionResponseNonNullableFields$1 as UpdateProjectOrderInCollectionResponseNonNullableFields, type context$2_UpdateProjectRequest as UpdateProjectRequest, type context$2_UpdateProjectResponse as UpdateProjectResponse, type context$2_UpdateProjectResponseNonNullableFields as UpdateProjectResponseNonNullableFields, type Video$1 as Video, type VideoResolution$1 as VideoResolution, WebhookIdentityType$2 as WebhookIdentityType, type context$2__publicOnProjectCreatedType as _publicOnProjectCreatedType, type context$2__publicOnProjectDeletedType as _publicOnProjectDeletedType, type context$2__publicOnProjectUpdatedType as _publicOnProjectUpdatedType, context$2_bulkUpdateProjects as bulkUpdateProjects, context$2_createProject as createProject, context$2_deleteProject as deleteProject, context$2_getProject as getProject, context$2_getProjectPageData as getProjectPageData, context$2_listProjects as listProjects, context$2_onProjectCreated as onProjectCreated, context$2_onProjectDeleted as onProjectDeleted, context$2_onProjectUpdated as onProjectUpdated, onProjectCreated$1 as publicOnProjectCreated, onProjectDeleted$1 as publicOnProjectDeleted, onProjectUpdated$1 as publicOnProjectUpdated, context$2_queryProjects as queryProjects, context$2_queryProjectsWithCollectionInfo as queryProjectsWithCollectionInfo, context$2_updateProject as updateProject, updateProjectOrderInCollection$2 as updateProjectOrderInCollection };
 }
 
+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$2<Payload = unknown, Type extends string = string> = {
+    __type: 'event-definition';
+    type: Type;
+    isDomainEvent?: boolean;
+    transformations?: (envelope: unknown) => Payload;
+    __payload: Payload;
+};
+declare function EventDefinition$2<Type extends string>(type: Type, isDomainEvent?: boolean, transformations?: (envelope: any) => unknown): <Payload = unknown>() => EventDefinition$2<Payload, Type>;
+type EventHandler$2<T extends EventDefinition$2> = (payload: T['__payload']) => void | Promise<void>;
+type BuildEventDefinition$2<T extends EventDefinition$2<any, string>> = (handler: EventHandler$2<T>) => void;
+
+type ServicePluginMethodInput$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$2<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$2<any> ? BuildEventDefinition$2<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 ProjectInCollection {
     /** Collection ID */
     collectionId?: string;
@@ -3530,11 +5580,6 @@ interface Project extends ProjectCoverOneOf {
     url?: string;
     /** SEO data for the project */
     seoData?: SeoSchema;
-    /**
-     * indicates if the project is synced from external platform (via integration page) and therefore will be updated from the external platform on daily basis
-     * @readonly
-     */
-    syncedProject?: boolean | null;
 }
 /** @oneof */
 interface ProjectCoverOneOf {
@@ -4111,7 +6156,7 @@ interface UpdateProjectOrderInCollectionIdentifiers {
     collectionId: string;
 }
 
-declare function queryProjectInCollections$1(httpClient: HttpClient): QueryProjectInCollectionsSignature;
+declare function queryProjectInCollections$1(httpClient: HttpClient$1): QueryProjectInCollectionsSignature;
 interface QueryProjectInCollectionsSignature {
     /**
      * Query project in collection context using [WQL - Wix Query Language](https://dev.wix.com/api/rest/getting-started/api-query-language)
@@ -4124,7 +6169,7 @@ interface QueryProjectInCollectionsSignature {
      */
     (options?: QueryProjectInCollectionsOptions | undefined): ProjectInCollectionsQueryBuilder;
 }
-declare function updateProjectOrderInCollection$1(httpClient: HttpClient): UpdateProjectOrderInCollectionSignature;
+declare function updateProjectOrderInCollection$1(httpClient: HttpClient$1): UpdateProjectOrderInCollectionSignature;
 interface UpdateProjectOrderInCollectionSignature {
     /**
      * Updates Project's order in a given Collection
@@ -4132,12 +6177,30 @@ interface UpdateProjectOrderInCollectionSignature {
      */
     (identifiers: UpdateProjectOrderInCollectionIdentifiers, sortOrder: number | null): Promise<UpdateProjectOrderInCollectionResponse & UpdateProjectOrderInCollectionResponseNonNullableFields>;
 }
-declare const onProjectInCollectionProjectOrderInCollectionUpdatedEvent$1: EventDefinition<ProjectInCollectionProjectOrderInCollectionUpdatedEnvelope, "wix.portfolio.projects.v1.project_in_collection_project_order_in_collection_updated_event">;
+declare const onProjectInCollectionProjectOrderInCollectionUpdatedEvent$1: EventDefinition$2<ProjectInCollectionProjectOrderInCollectionUpdatedEnvelope, "wix.portfolio.projects.v1.project_in_collection_project_order_in_collection_updated_event">;
 
-declare function createEventModule<T extends EventDefinition<any, string>>(eventDefinition: T): BuildEventDefinition<T> & T;
+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;
 
-declare const queryProjectInCollections: BuildRESTFunction<typeof queryProjectInCollections$1> & typeof queryProjectInCollections$1;
-declare const updateProjectOrderInCollection: BuildRESTFunction<typeof updateProjectOrderInCollection$1> & typeof updateProjectOrderInCollection$1;
+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$1<any, string>>(eventDefinition: T): BuildEventDefinition$1<T> & T;
+
+declare const queryProjectInCollections: MaybeContext$1<BuildRESTFunction$1<typeof queryProjectInCollections$1> & typeof queryProjectInCollections$1>;
+declare const updateProjectOrderInCollection: MaybeContext$1<BuildRESTFunction$1<typeof updateProjectOrderInCollection$1> & typeof updateProjectOrderInCollection$1>;
 
 type _publicOnProjectInCollectionProjectOrderInCollectionUpdatedEventType = typeof onProjectInCollectionProjectOrderInCollectionUpdatedEvent$1;
 /** */
@@ -4189,6 +6252,416 @@ declare namespace context$1 {
   export { type ActionEvent$1 as ActionEvent, type context$1_BaseEventMetadata as BaseEventMetadata, type CursorPaging$1 as CursorPaging, type Cursors$1 as Cursors, type context$1_DetailsLink as DetailsLink, type DomainEvent$1 as DomainEvent, type DomainEventBodyOneOf$1 as DomainEventBodyOneOf, type EntityCreatedEvent$1 as EntityCreatedEvent, type EntityDeletedEvent$1 as EntityDeletedEvent, type EntityUpdatedEvent$1 as EntityUpdatedEvent, type context$1_EventMetadata as EventMetadata, type IdentificationData$1 as IdentificationData, type IdentificationDataIdOneOf$1 as IdentificationDataIdOneOf, type context$1_Image as Image, context$1_ImageType as ImageType, type context$1_Keyword as Keyword, type MessageEnvelope$1 as MessageEnvelope, type context$1_Paging as Paging, type PagingMetadataV2$1 as PagingMetadataV2, type context$1_Point as Point, type context$1_Project as Project, type context$1_ProjectCoverOneOf as ProjectCoverOneOf, type context$1_ProjectDetail as ProjectDetail, type context$1_ProjectDetailValueOneOf as ProjectDetailValueOneOf, type context$1_ProjectInCollection as ProjectInCollection, type context$1_ProjectInCollectionProjectOrderInCollectionUpdatedEnvelope as ProjectInCollectionProjectOrderInCollectionUpdatedEnvelope, type context$1_ProjectInCollectionsQueryBuilder as ProjectInCollectionsQueryBuilder, type context$1_ProjectInCollectionsQueryResult as ProjectInCollectionsQueryResult, type context$1_ProjectOrderInCollectionUpdatedEvent as ProjectOrderInCollectionUpdatedEvent, type context$1_ProjectSource as ProjectSource, type context$1_QueryProjectInCollectionsOptions as QueryProjectInCollectionsOptions, type context$1_QueryProjectInCollectionsRequest as QueryProjectInCollectionsRequest, type context$1_QueryProjectInCollectionsResponse as QueryProjectInCollectionsResponse, type context$1_QueryProjectInCollectionsResponseNonNullableFields as QueryProjectInCollectionsResponseNonNullableFields, type context$1_QueryV2 as QueryV2, type context$1_QueryV2PagingMethodOneOf as QueryV2PagingMethodOneOf, type RestoreInfo$1 as RestoreInfo, type context$1_SeoSchema as SeoSchema, type context$1_Settings as Settings, context$1_SortOrder as SortOrder, type context$1_Sorting as Sorting, SyncStatus$1 as SyncStatus, type context$1_Tag as Tag, type context$1_UnsharpMasking as UnsharpMasking, type context$1_UpdateProjectOrderInCollectionIdentifiers as UpdateProjectOrderInCollectionIdentifiers, type context$1_UpdateProjectOrderInCollectionRequest as UpdateProjectOrderInCollectionRequest, type context$1_UpdateProjectOrderInCollectionResponse as UpdateProjectOrderInCollectionResponse, type context$1_UpdateProjectOrderInCollectionResponseNonNullableFields as UpdateProjectOrderInCollectionResponseNonNullableFields, type context$1_Video as Video, type context$1_VideoResolution as VideoResolution, WebhookIdentityType$1 as WebhookIdentityType, type context$1__publicOnProjectInCollectionProjectOrderInCollectionUpdatedEventType as _publicOnProjectInCollectionProjectOrderInCollectionUpdatedEventType, context$1_onProjectInCollectionProjectOrderInCollectionUpdatedEvent as onProjectInCollectionProjectOrderInCollectionUpdatedEvent, onProjectInCollectionProjectOrderInCollectionUpdatedEvent$1 as publicOnProjectInCollectionProjectOrderInCollectionUpdatedEvent, context$1_queryProjectInCollections as queryProjectInCollections, context$1_updateProjectOrderInCollection as updateProjectOrderInCollection };
 }
 
+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<Payload = unknown, Type extends string = string> = {
+    __type: 'event-definition';
+    type: Type;
+    isDomainEvent?: boolean;
+    transformations?: (envelope: unknown) => Payload;
+    __payload: Payload;
+};
+declare function EventDefinition<Type extends string>(type: Type, isDomainEvent?: boolean, transformations?: (envelope: any) => unknown): <Payload = unknown>() => EventDefinition<Payload, Type>;
+type EventHandler<T extends EventDefinition> = (payload: T['__payload']) => void | Promise<void>;
+type BuildEventDefinition<T extends EventDefinition<any, string>> = (handler: EventHandler<T>) => void;
+
+type ServicePluginMethodInput = {
+    request: any;
+    metadata: any;
+};
+type ServicePluginContract = Record<string, (payload: ServicePluginMethodInput) => unknown | Promise<unknown>>;
+type ServicePluginMethodMetadata = {
+    name: string;
+    primaryHttpMappingPath: string;
+    transformations: {
+        fromREST: (...args: unknown[]) => ServicePluginMethodInput;
+        toREST: (...args: unknown[]) => unknown;
+    };
+};
+type ServicePluginDefinition<Contract extends ServicePluginContract> = {
+    __type: 'service-plugin-definition';
+    componentType: string;
+    methods: ServicePluginMethodMetadata[];
+    __contract: Contract;
+};
+declare function ServicePluginDefinition<Contract extends ServicePluginContract>(componentType: string, methods: ServicePluginMethodMetadata[]): ServicePluginDefinition<Contract>;
+type BuildServicePluginDefinition<T extends ServicePluginDefinition<any>> = (implementation: T['__contract']) => void;
+declare const SERVICE_PLUGIN_ERROR_TYPE = "wix_spi_error";
+
+type RequestContext = {
+    isSSR: boolean;
+    host: string;
+    protocol?: string;
+};
+type ResponseTransformer = (data: any, headers?: any) => any;
+/**
+ * Ambassador request options types are copied mostly from AxiosRequestConfig.
+ * They are copied and not imported to reduce the amount of dependencies (to reduce install time).
+ * https://github.com/axios/axios/blob/3f53eb6960f05a1f88409c4b731a40de595cb825/index.d.ts#L307-L315
+ */
+type Method = 'get' | 'GET' | 'delete' | 'DELETE' | 'head' | 'HEAD' | 'options' | 'OPTIONS' | 'post' | 'POST' | 'put' | 'PUT' | 'patch' | 'PATCH' | 'purge' | 'PURGE' | 'link' | 'LINK' | 'unlink' | 'UNLINK';
+type AmbassadorRequestOptions<T = any> = {
+    _?: T;
+    url?: string;
+    method?: Method;
+    params?: any;
+    data?: any;
+    transformResponse?: ResponseTransformer | ResponseTransformer[];
+};
+type AmbassadorFactory<Request, Response> = (payload: Request) => ((context: RequestContext) => AmbassadorRequestOptions<Response>) & {
+    __isAmbassador: boolean;
+};
+type AmbassadorFunctionDescriptor<Request = any, Response = any> = AmbassadorFactory<Request, Response>;
+type BuildAmbassadorFunction<T extends AmbassadorFunctionDescriptor> = T extends AmbassadorFunctionDescriptor<infer Request, infer Response> ? (req: Request) => Promise<Response> : never;
+
+declare global {
+	// eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
+	interface SymbolConstructor {
+		readonly observable: symbol;
+	}
+}
+
+declare const emptyObjectSymbol: unique symbol;
+
+/**
+Represents a strictly empty plain object, the `{}` value.
+
+When you annotate something as the type `{}`, it can be anything except `null` and `undefined`. This means that you cannot use `{}` to represent an empty plain object ([read more](https://stackoverflow.com/questions/47339869/typescript-empty-object-and-any-difference/52193484#52193484)).
+
+@example
+```
+import type {EmptyObject} from 'type-fest';
+
+// The following illustrates the problem with `{}`.
+const foo1: {} = {}; // Pass
+const foo2: {} = []; // Pass
+const foo3: {} = 42; // Pass
+const foo4: {} = {a: 1}; // Pass
+
+// With `EmptyObject` only the first case is valid.
+const bar1: EmptyObject = {}; // Pass
+const bar2: EmptyObject = 42; // Fail
+const bar3: EmptyObject = []; // Fail
+const bar4: EmptyObject = {a: 1}; // Fail
+```
+
+Unfortunately, `Record<string, never>`, `Record<keyof any, never>` and `Record<never, never>` do not work. See {@link https://github.com/sindresorhus/type-fest/issues/395 #395}.
+
+@category Object
+*/
+type EmptyObject = {[emptyObjectSymbol]?: never};
+
+/**
+Returns a boolean for whether the two given types are equal.
+
+@link https://github.com/microsoft/TypeScript/issues/27024#issuecomment-421529650
+@link https://stackoverflow.com/questions/68961864/how-does-the-equals-work-in-typescript/68963796#68963796
+
+Use-cases:
+- If you want to make a conditional branch based on the result of a comparison of two types.
+
+@example
+```
+import type {IsEqual} from 'type-fest';
+
+// This type returns a boolean for whether the given array includes the given item.
+// `IsEqual` is used to compare the given array at position 0 and the given item and then return true if they are equal.
+type Includes<Value extends readonly any[], Item> =
+	Value extends readonly [Value[0], ...infer rest]
+		? IsEqual<Value[0], Item> extends true
+			? true
+			: Includes<rest, Item>
+		: false;
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsEqual<A, B> =
+	(<G>() => G extends A ? 1 : 2) extends
+	(<G>() => G extends B ? 1 : 2)
+		? true
+		: false;
+
+/**
+Filter out keys from an object.
+
+Returns `never` if `Exclude` is strictly equal to `Key`.
+Returns `never` if `Key` extends `Exclude`.
+Returns `Key` otherwise.
+
+@example
+```
+type Filtered = Filter<'foo', 'foo'>;
+//=> never
+```
+
+@example
+```
+type Filtered = Filter<'bar', string>;
+//=> never
+```
+
+@example
+```
+type Filtered = Filter<'bar', 'foo'>;
+//=> 'bar'
+```
+
+@see {Except}
+*/
+type Filter<KeyType, ExcludeType> = IsEqual<KeyType, ExcludeType> extends true ? never : (KeyType extends ExcludeType ? never : KeyType);
+
+type ExceptOptions = {
+	/**
+	Disallow assigning non-specified properties.
+
+	Note that any omitted properties in the resulting type will be present in autocomplete as `undefined`.
+
+	@default false
+	*/
+	requireExactProps?: boolean;
+};
+
+/**
+Create a type from an object type without certain keys.
+
+We recommend setting the `requireExactProps` option to `true`.
+
+This type is a stricter version of [`Omit`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-5.html#the-omit-helper-type). The `Omit` type does not restrict the omitted keys to be keys present on the given type, while `Except` does. The benefits of a stricter type are avoiding typos and allowing the compiler to pick up on rename refactors automatically.
+
+This type was proposed to the TypeScript team, which declined it, saying they prefer that libraries implement stricter versions of the built-in types ([microsoft/TypeScript#30825](https://github.com/microsoft/TypeScript/issues/30825#issuecomment-523668235)).
+
+@example
+```
+import type {Except} from 'type-fest';
+
+type Foo = {
+	a: number;
+	b: string;
+};
+
+type FooWithoutA = Except<Foo, 'a'>;
+//=> {b: string}
+
+const fooWithoutA: FooWithoutA = {a: 1, b: '2'};
+//=> errors: 'a' does not exist in type '{ b: string; }'
+
+type FooWithoutB = Except<Foo, 'b', {requireExactProps: true}>;
+//=> {a: number} & Partial<Record<"b", never>>
+
+const fooWithoutB: FooWithoutB = {a: 1, b: '2'};
+//=> errors at 'b': Type 'string' is not assignable to type 'undefined'.
+```
+
+@category Object
+*/
+type Except<ObjectType, KeysType extends keyof ObjectType, Options extends ExceptOptions = {requireExactProps: false}> = {
+	[KeyType in keyof ObjectType as Filter<KeyType, KeysType>]: ObjectType[KeyType];
+} & (Options['requireExactProps'] extends true
+	? Partial<Record<KeysType, never>>
+	: {});
+
+/**
+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<any> | ServicePluginDefinition<any> | {
+    [key: string]: Descriptors | PublicMetadata | any;
+};
+/**
+ * This type takes in a descriptors object of a certain Host (including an `unknown` host)
+ * and returns an object with the same structure, but with all descriptors replaced with their API.
+ * Any non-descriptor properties are removed from the returned object, including descriptors that
+ * do not match the given host (as they will not work with the given host).
+ */
+type BuildDescriptors<T extends Descriptors, H extends Host<any> | undefined, Depth extends number = 5> = {
+    done: T;
+    recurse: T extends {
+        __type: typeof SERVICE_PLUGIN_ERROR_TYPE;
+    } ? never : T extends AmbassadorFunctionDescriptor ? BuildAmbassadorFunction<T> : T extends RESTFunctionDescriptor ? BuildRESTFunction<T> : T extends EventDefinition<any> ? BuildEventDefinition<T> : T extends ServicePluginDefinition<any> ? BuildServicePluginDefinition<T> : T extends HostModule<any, any> ? HostModuleAPI<T> : ConditionalExcept<{
+        [Key in keyof T]: T[Key] extends Descriptors ? BuildDescriptors<T[Key], H, [
+            -1,
+            0,
+            1,
+            2,
+            3,
+            4,
+            5
+        ][Depth]> : never;
+    }, EmptyObject>;
+}[Depth extends -1 ? 'done' : 'recurse'];
+type PublicMetadata = {
+    PACKAGE_NAME?: string;
+};
+
+declare global {
+    interface ContextualClient {
+    }
+}
+/**
+ * A type used to create concerete types from SDK descriptors in
+ * case a contextual client is available.
+ */
+type MaybeContext<T extends Descriptors> = globalThis.ContextualClient extends {
+    host: Host;
+} ? BuildDescriptors<T, globalThis.ContextualClient['host']> : T;
+
 interface SyncedProject {
     /** Project ID in Portfolio - if project was yet to be create, will be None */
     portfolioProjectId?: string | null;
@@ -4872,11 +7345,11 @@ interface GetLoginRedirectableUrlSignature {
     (appDefId: string): Promise<GetLoginRedirectableUrlResponse & GetLoginRedirectableUrlResponseNonNullableFields>;
 }
 
-declare const getProjects: BuildRESTFunction<typeof getProjects$1> & typeof getProjects$1;
-declare const syncProject: BuildRESTFunction<typeof syncProject$1> & typeof syncProject$1;
-declare const getSyncStatus: BuildRESTFunction<typeof getSyncStatus$1> & typeof getSyncStatus$1;
-declare const stopSync: BuildRESTFunction<typeof stopSync$1> & typeof stopSync$1;
-declare const getLoginRedirectableUrl: BuildRESTFunction<typeof getLoginRedirectableUrl$1> & typeof getLoginRedirectableUrl$1;
+declare const getProjects: MaybeContext<BuildRESTFunction<typeof getProjects$1> & typeof getProjects$1>;
+declare const syncProject: MaybeContext<BuildRESTFunction<typeof syncProject$1> & typeof syncProject$1>;
+declare const getSyncStatus: MaybeContext<BuildRESTFunction<typeof getSyncStatus$1> & typeof getSyncStatus$1>;
+declare const stopSync: MaybeContext<BuildRESTFunction<typeof stopSync$1> & typeof stopSync$1>;
+declare const getLoginRedirectableUrl: MaybeContext<BuildRESTFunction<typeof getLoginRedirectableUrl$1> & typeof getLoginRedirectableUrl$1>;
 
 type context_ActionEvent = ActionEvent;
 type context_Asset = Asset;