@wix/data 1.0.144 → 1.0.145

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

@@ -1,3 +1,47 @@
+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>;
+}
+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;
+
+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;
+	}
+}
+
 /** An external database connection defines a connection between an external database and a Wix site or project. */
 interface ExternalDatabaseConnection {
     /**
@@ -415,55 +459,64 @@ interface UpdateExternalDatabaseConnection {
     capabilities?: Capabilities;
 }
 
-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>;
+declare function getExternalDatabaseConnection$1(httpClient: HttpClient): GetExternalDatabaseConnectionSignature;
+interface GetExternalDatabaseConnectionSignature {
+    /**
+     * Retrieves an external database connection by name.
+     * @param - Name of the external database connection to retrieve.
+     * @returns Details of the external database connection requested.
+     */
+    (name: string): Promise<ExternalDatabaseConnection & ExternalDatabaseConnectionNonNullableFields>;
 }
-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;
-
-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 listExternalDatabaseConnections$1(httpClient: HttpClient): ListExternalDatabaseConnectionsSignature;
+interface ListExternalDatabaseConnectionsSignature {
+    /**
+     * Retrieves a list of all external database collections associated with the site or project.
+     */
+    (options?: ListExternalDatabaseConnectionsOptions | undefined): Promise<ListExternalDatabaseConnectionsResponse & ListExternalDatabaseConnectionsResponseNonNullableFields>;
+}
+declare function createExternalDatabaseConnection$1(httpClient: HttpClient): CreateExternalDatabaseConnectionSignature;
+interface CreateExternalDatabaseConnectionSignature {
+    /**
+     * Creates a new external database connection.
+     *
+     * The `externalDatabaseConnection` parameter must include a `name`, `endpoint`, and `configuration` details for the external database.
+     * If any of these are missing, the external database connection isn't created.
+     * @param - External database connection details.
+     * @param - Options for creating an external database connection.
+     * @returns Details of external database connection created.
+     */
+    (externalDatabaseConnection: ExternalDatabaseConnection, options: CreateExternalDatabaseConnectionOptions): Promise<ExternalDatabaseConnection & ExternalDatabaseConnectionNonNullableFields>;
+}
+declare function updateExternalDatabaseConnection$1(httpClient: HttpClient): UpdateExternalDatabaseConnectionSignature;
+interface UpdateExternalDatabaseConnectionSignature {
+    /**
+     * Updates an external database connection.
+     *
+     * An external database collection name must be provided in `name`.
+     * If an existing external database connection is found with the same name, that connection's details are updated.
+     * If no external database connection has that name, the request fails.
+     *
+     * > **Note:** After an external database connection is updated, it only contains the values provided in the request. All previous values are lost.
+     * @param - Name of the external database connection.
+     * An external database connection may connect to one or more external data collections or tables.
+     * These are represented as `connectionName/dataCollectionId`.
+     * @param - Options for updating an external database connection.
+     * @param - Updated external database connection details. The existing connection is replaced with this version.
+     * @returns Updated external database connection details.
+     */
+    (name: string, externalDatabaseConnection: UpdateExternalDatabaseConnection): Promise<ExternalDatabaseConnection & ExternalDatabaseConnectionNonNullableFields>;
+}
+declare function deleteExternalDatabaseConnection$1(httpClient: HttpClient): DeleteExternalDatabaseConnectionSignature;
+interface DeleteExternalDatabaseConnectionSignature {
+    /**
+     * Deletes an external database connection.
+     *
+     * > **Note:** Once an external database connection is deleted, it can't be restored. To reconnect the database you need to create a new external database connection.
+     * @param - Name of the external database connection to delete.
+     */
+    (name: string): Promise<void>;
 }
-
-declare function getExternalDatabaseConnection$1(httpClient: HttpClient): (name: string) => Promise<ExternalDatabaseConnection & ExternalDatabaseConnectionNonNullableFields>;
-declare function listExternalDatabaseConnections$1(httpClient: HttpClient): (options?: ListExternalDatabaseConnectionsOptions) => Promise<ListExternalDatabaseConnectionsResponse & ListExternalDatabaseConnectionsResponseNonNullableFields>;
-declare function createExternalDatabaseConnection$1(httpClient: HttpClient): (externalDatabaseConnection: ExternalDatabaseConnection, options: CreateExternalDatabaseConnectionOptions) => Promise<ExternalDatabaseConnection & ExternalDatabaseConnectionNonNullableFields>;
-declare function updateExternalDatabaseConnection$1(httpClient: HttpClient): (name: string, externalDatabaseConnection: UpdateExternalDatabaseConnection) => Promise<ExternalDatabaseConnection & ExternalDatabaseConnectionNonNullableFields>;
-declare function deleteExternalDatabaseConnection$1(httpClient: HttpClient): (name: string) => Promise<void>;
 declare const onExternalDatabaseConnectionCreated$1: EventDefinition<ExternalDatabaseConnectionCreatedEnvelope, "wix.data.v1.external_database_connection_created">;
 declare const onExternalDatabaseConnectionUpdated$1: EventDefinition<ExternalDatabaseConnectionUpdatedEnvelope, "wix.data.v1.external_database_connection_updated">;
 declare const onExternalDatabaseConnectionDeleted$1: EventDefinition<ExternalDatabaseConnectionDeletedEnvelope, "wix.data.v1.external_database_connection_deleted">;
@@ -484,12 +537,21 @@ type _publicDeleteExternalDatabaseConnectionType = typeof deleteExternalDatabase
 declare const deleteExternalDatabaseConnection: ReturnType<typeof createRESTModule$3<_publicDeleteExternalDatabaseConnectionType>>;
 
 type _publicOnExternalDatabaseConnectionCreatedType = typeof onExternalDatabaseConnectionCreated$1;
+/**
+ * Triggered when an external database connection is created.
+ */
 declare const onExternalDatabaseConnectionCreated: ReturnType<typeof createEventModule$2<_publicOnExternalDatabaseConnectionCreatedType>>;
 
 type _publicOnExternalDatabaseConnectionUpdatedType = typeof onExternalDatabaseConnectionUpdated$1;
+/**
+ * Triggered when an external database connection is updated.
+ */
 declare const onExternalDatabaseConnectionUpdated: ReturnType<typeof createEventModule$2<_publicOnExternalDatabaseConnectionUpdatedType>>;
 
 type _publicOnExternalDatabaseConnectionDeletedType = typeof onExternalDatabaseConnectionDeleted$1;
+/**
+ * Triggered when an external database connection is deleted.
+ */
 declare const onExternalDatabaseConnectionDeleted: ReturnType<typeof createEventModule$2<_publicOnExternalDatabaseConnectionDeletedType>>;
 
 type context$3_Capabilities = Capabilities;
@@ -1004,7 +1066,10 @@ declare enum Role {
     ANYONE = "ANYONE"
 }
 interface Plugin extends PluginOptionsOneOf {
-    /** Options for the Publish plugin. */
+    /**
+     * Options for the Publish plugin.
+     * This plugin allows items in a [data collection](https://dev.wix.com/docs/rest/business-solutions/cms/data-collections/data-collection-object) to be marked as draft or published. Published items are visible to site visitors, while draft items are not.
+     */
     publishOptions?: PublishPluginOptions$1;
     /** Options for the Single Item plugin. */
     singleItemOptions?: SingleItemPluginOptions;
@@ -1029,7 +1094,10 @@ interface Plugin extends PluginOptionsOneOf {
 }
 /** @oneof */
 interface PluginOptionsOneOf {
-    /** Options for the Publish plugin. */
+    /**
+     * Options for the Publish plugin.
+     * This plugin allows items in a [data collection](https://dev.wix.com/docs/rest/business-solutions/cms/data-collections/data-collection-object) to be marked as draft or published. Published items are visible to site visitors, while draft items are not.
+     */
     publishOptions?: PublishPluginOptions$1;
     /** Options for the Single Item plugin. */
     singleItemOptions?: SingleItemPluginOptions;
@@ -1847,11 +1915,69 @@ interface ListDataCollectionsOptions {
     consistentRead?: boolean;
 }
 
-declare function createDataCollection$1(httpClient: HttpClient): (collection: DataCollection) => Promise<DataCollection & DataCollectionNonNullableFields>;
-declare function getDataCollection$1(httpClient: HttpClient): (dataCollectionId: string, options?: GetDataCollectionOptions) => Promise<DataCollection & DataCollectionNonNullableFields>;
-declare function listDataCollections$1(httpClient: HttpClient): (options?: ListDataCollectionsOptions) => Promise<ListDataCollectionsResponse & ListDataCollectionsResponseNonNullableFields>;
-declare function updateDataCollection$1(httpClient: HttpClient): (collection: DataCollection) => Promise<DataCollection & DataCollectionNonNullableFields>;
-declare function deleteDataCollection$1(httpClient: HttpClient): (dataCollectionId: string) => Promise<void>;
+declare function createDataCollection$1(httpClient: HttpClient): CreateDataCollectionSignature;
+interface CreateDataCollectionSignature {
+    /**
+     * Creates a new data collection.
+     *
+     * The request body must include an ID, details for at least 1 field, and a permissions object. If any of these are missing, the collection isn't created.
+     * @param - Collection details.
+     * @param - Options for creating a data collection.
+     * @returns Details of collection created.
+     */
+    (collection: DataCollection): Promise<DataCollection & DataCollectionNonNullableFields>;
+}
+declare function getDataCollection$1(httpClient: HttpClient): GetDataCollectionSignature;
+interface GetDataCollectionSignature {
+    /**
+     * Retrieves a data collection by ID.
+     * @param - ID of the collection to retrieve.
+     * @param - Options for retrieving a data collection.
+     * @returns Details of the collection requested.
+     */
+    (dataCollectionId: string, options?: GetDataCollectionOptions | undefined): Promise<DataCollection & DataCollectionNonNullableFields>;
+}
+declare function listDataCollections$1(httpClient: HttpClient): ListDataCollectionsSignature;
+interface ListDataCollectionsSignature {
+    /**
+     * Retrieves a list of all data collections associated with the site or project.
+     *
+     * By default, the list is ordered by ID in ascending order.
+     * @param - Options for retrieving a list of data collections.
+     */
+    (options?: ListDataCollectionsOptions | undefined): Promise<ListDataCollectionsResponse & ListDataCollectionsResponseNonNullableFields>;
+}
+declare function updateDataCollection$1(httpClient: HttpClient): UpdateDataCollectionSignature;
+interface UpdateDataCollectionSignature {
+    /**
+     * Updates a data collection.
+     *
+     * A collection ID, revision number, permissions, and at least 1 field must be provided within `options.collection`.
+     * If a collection with that ID exists, and if its current `revision` number matches the one provided, it is updated.
+     * Otherwise, the request fails.
+     *
+     * When a collection is updated, its `_updatedDate` property is changed to the current date and its `revision` property is incremented.
+     *
+     * > **Note:**
+     * > After a collection is updated, it only contains the properties included in the `updateDataCollection()` call. If the existing collection has properties with values and those properties
+     * > aren't included in the updated collection details, their values are lost.
+     * @param - Updated collection details. The existing collection is replaced with this version.
+     * @param - Options for updating a data collection.
+     * @returns Updated collection details.
+     */
+    (collection: DataCollection): Promise<DataCollection & DataCollectionNonNullableFields>;
+}
+declare function deleteDataCollection$1(httpClient: HttpClient): DeleteDataCollectionSignature;
+interface DeleteDataCollectionSignature {
+    /**
+     * Deletes a data collection.
+     *
+     * > **Note:**
+     * > Once a collection is deleted, it can't be restored.
+     * @param - ID of the collection to delete.
+     */
+    (dataCollectionId: string): Promise<void>;
+}
 declare const onDataCollectionClonedEvent$1: EventDefinition<DataCollectionClonedEnvelope, "wix.data.v2.data_collection_data_collection_cloned_event">;
 declare const onDataCollectionChangedEvent$1: EventDefinition<DataCollectionChangedEnvelope, "wix.data.v2.data_collection_data_collection_changed_event">;
 declare const onDataCollectionCreated$1: EventDefinition<DataCollectionCreatedEnvelope, "wix.data.v2.data_collection_created">;
@@ -1874,18 +2000,29 @@ type _publicDeleteDataCollectionType = typeof deleteDataCollection$1;
 declare const deleteDataCollection: ReturnType<typeof createRESTModule$2<_publicDeleteDataCollectionType>>;
 
 type _publicOnDataCollectionClonedEventType = typeof onDataCollectionClonedEvent$1;
+/**
+ * Event triggered when collection is cloned from other instance
+ * CREATED event will be also triggered along with this action
+ */
 declare const onDataCollectionClonedEvent: ReturnType<typeof createEventModule$1<_publicOnDataCollectionClonedEventType>>;
 
 type _publicOnDataCollectionChangedEventType = typeof onDataCollectionChangedEvent$1;
+/**
+ * Event triggered when collection is changed, describing some of changes
+ * UPDATED event will be also triggered along with this action
+ */
 declare const onDataCollectionChangedEvent: ReturnType<typeof createEventModule$1<_publicOnDataCollectionChangedEventType>>;
 
 type _publicOnDataCollectionCreatedType = typeof onDataCollectionCreated$1;
+/** */
 declare const onDataCollectionCreated: ReturnType<typeof createEventModule$1<_publicOnDataCollectionCreatedType>>;
 
 type _publicOnDataCollectionUpdatedType = typeof onDataCollectionUpdated$1;
+/** */
 declare const onDataCollectionUpdated: ReturnType<typeof createEventModule$1<_publicOnDataCollectionUpdatedType>>;
 
 type _publicOnDataCollectionDeletedType = typeof onDataCollectionDeleted$1;
+/** */
 declare const onDataCollectionDeleted: ReturnType<typeof createEventModule$1<_publicOnDataCollectionDeletedType>>;
 
 type context$2_AccessLevel = AccessLevel;
@@ -2110,6 +2247,12 @@ interface RemoveFromArray {
     value?: any;
 }
 interface DataPublishPluginOptions {
+    /**
+     * Whether to include draft items.
+     * When `true`, the response includes both published and draft items. Default: `false`.
+     *
+     * **Note:** This option is only relevant for [data collections](https://dev.wix.com/docs/rest/business-solutions/cms/data-collections/data-collection-object) that use the Publish plugin.
+     */
     includeDraftItems?: boolean;
 }
 interface PatchDataItemResponse {
@@ -3566,27 +3709,322 @@ interface ReplaceDataItemReferencesOptions {
     newReferencedItemIds?: string[];
 }
 
-declare function insertDataItem$1(httpClient: HttpClient): (options: InsertDataItemOptions) => Promise<InsertDataItemResponse & InsertDataItemResponseNonNullableFields>;
-declare function updateDataItem$1(httpClient: HttpClient): (_id: string, options: UpdateDataItemOptions) => Promise<UpdateDataItemResponse & UpdateDataItemResponseNonNullableFields>;
-declare function saveDataItem$1(httpClient: HttpClient): (options: SaveDataItemOptions) => Promise<SaveDataItemResponse & SaveDataItemResponseNonNullableFields>;
-declare function getDataItem$1(httpClient: HttpClient): (dataItemId: string, options?: GetDataItemOptions) => Promise<DataItem & DataItemNonNullableFields>;
-declare function removeDataItem$1(httpClient: HttpClient): (dataItemId: string, options: RemoveDataItemOptions) => Promise<RemoveDataItemResponse & RemoveDataItemResponseNonNullableFields>;
-declare function truncateDataItems$1(httpClient: HttpClient): (options: TruncateDataItemsOptions) => Promise<void>;
-declare function queryDataItems$1(httpClient: HttpClient): (options: QueryDataItemsOptions) => DataItemsQueryBuilder;
-declare function aggregateDataItems$1(httpClient: HttpClient): (options?: AggregateDataItemsOptions) => Promise<AggregateDataItemsResponse>;
-declare function countDataItems$1(httpClient: HttpClient): (options?: CountDataItemsOptions) => Promise<CountDataItemsResponse & CountDataItemsResponseNonNullableFields>;
-declare function queryDistinctValues$1(httpClient: HttpClient): (options?: QueryDistinctValuesOptions) => Promise<QueryDistinctValuesResponse>;
-declare function bulkInsertDataItems$1(httpClient: HttpClient): (options?: BulkInsertDataItemsOptions) => Promise<BulkInsertDataItemsResponse & BulkInsertDataItemsResponseNonNullableFields>;
-declare function bulkUpdateDataItems$1(httpClient: HttpClient): (options?: BulkUpdateDataItemsOptions) => Promise<BulkUpdateDataItemsResponse & BulkUpdateDataItemsResponseNonNullableFields>;
-declare function bulkSaveDataItems$1(httpClient: HttpClient): (options?: BulkSaveDataItemsOptions) => Promise<BulkSaveDataItemsResponse & BulkSaveDataItemsResponseNonNullableFields>;
-declare function bulkRemoveDataItems$1(httpClient: HttpClient): (options: BulkRemoveDataItemsOptions) => Promise<BulkRemoveDataItemsResponse & BulkRemoveDataItemsResponseNonNullableFields>;
-declare function queryReferencedDataItems$1(httpClient: HttpClient): (options?: QueryReferencedDataItemsOptions) => Promise<QueryReferencedDataItemsResponse & QueryReferencedDataItemsResponseNonNullableFields>;
-declare function isReferencedDataItem$1(httpClient: HttpClient): (options?: IsReferencedDataItemOptions) => Promise<IsReferencedDataItemResponse & IsReferencedDataItemResponseNonNullableFields>;
-declare function insertDataItemReference$1(httpClient: HttpClient): (options?: InsertDataItemReferenceOptions) => Promise<InsertDataItemReferenceResponse & InsertDataItemReferenceResponseNonNullableFields>;
-declare function removeDataItemReference$1(httpClient: HttpClient): (options: RemoveDataItemReferenceOptions) => Promise<RemoveDataItemReferenceResponse & RemoveDataItemReferenceResponseNonNullableFields>;
-declare function bulkInsertDataItemReferences$1(httpClient: HttpClient): (options?: BulkInsertDataItemReferencesOptions) => Promise<BulkInsertDataItemReferencesResponse & BulkInsertDataItemReferencesResponseNonNullableFields>;
-declare function bulkRemoveDataItemReferences$1(httpClient: HttpClient): (options: BulkRemoveDataItemReferencesOptions) => Promise<BulkRemoveDataItemReferencesResponse & BulkRemoveDataItemReferencesResponseNonNullableFields>;
-declare function replaceDataItemReferences$1(httpClient: HttpClient): (options?: ReplaceDataItemReferencesOptions) => Promise<ReplaceDataItemReferencesResponse & ReplaceDataItemReferencesResponseNonNullableFields>;
+declare function insertDataItem$1(httpClient: HttpClient): InsertDataItemSignature;
+interface InsertDataItemSignature {
+    /**
+     * Adds an item to a collection.
+     *
+     *
+     * An item can only be inserted into an existing connection.
+     * You can create a new collection using the Data Collections API.
+     *
+     * When an item is inserted into a collection, the item's ID is automatically assigned a random value.
+     * You can optionally provide a custom ID in `dataItem.id` when inserting the item.
+     * If you specify an ID that already exists in the collection, the insertion will fail.
+     *
+     * If `options.dataItem.data` is empty, a new item is created with no data fields.
+     * @param - Options for adding an item to a collection.
+     */
+    (options: InsertDataItemOptions): Promise<InsertDataItemResponse & InsertDataItemResponseNonNullableFields>;
+}
+declare function updateDataItem$1(httpClient: HttpClient): UpdateDataItemSignature;
+interface UpdateDataItemSignature {
+    /**
+     * Updates an item in a collection.
+     *
+     *
+     * This function replaces the data item's existing data with the payload provided in `options.dataItem.data` in the request.
+     *
+     * To update an item, you need to specify an item ID and a collection ID.
+     * If an item is found in the specified collection with the specified ID, that item is updated.
+     * If the collection doesn't contain an item with that ID, the request fails.
+     *
+     * When an item is updated, its `data._updatedDate` field is changed to the current date and time.
+     *
+     * > **Note:**
+     * > After an item is updated, it only contains the fields included in the `options.dataItem.data` payload in the `updateDataItem()` call.
+     * > If the existing item has fields with values and those fields aren't included in the updated item, their values are lost.
+     * @param - Data item ID.
+     * @param - Options for updating an item in a collection.
+     */
+    (_id: string, options: UpdateDataItemOptions): Promise<UpdateDataItemResponse & UpdateDataItemResponseNonNullableFields>;
+}
+declare function saveDataItem$1(httpClient: HttpClient): SaveDataItemSignature;
+interface SaveDataItemSignature {
+    /**
+     * Inserts or updates an item in a collection.
+     *
+     *
+     * The `saveDataItem()` function inserts or updates the specified item, depending on whether it already exists in the collection.
+     *
+     * + If you don't provide an ID, a new item is created.
+     *
+     * + If you provide an ID that does not exist in the collection, a new item is created with that ID.
+     *
+     * + If an item with the ID you provide already exists in the collection, that item is updated. When an item is updated, its `data._updatedDate` field is changed to the current date and time.
+     *
+     * > **Note:** When you provide an item with an ID that already exists in the collection, the payload you provide in `options.dataItem.data` replaces the existing item with that ID.
+     * > This means that the item's previous fields and values are lost.
+     * @param - Options for saving an item in a collection.
+     */
+    (options: SaveDataItemOptions): Promise<SaveDataItemResponse & SaveDataItemResponseNonNullableFields>;
+}
+declare function getDataItem$1(httpClient: HttpClient): GetDataItemSignature;
+interface GetDataItemSignature {
+    /**
+     * Retrieves an item from a collection.
+     *
+     *
+     * > **Note**: When calling `getDataItem()` following an update to your collection, the data retrieved may not contain the most recent changes. If you need the most up-to-date data, set `options.consistentRead` to `true`.
+     * @param - ID of the data item to retrieve.
+     * @param - Options for retrieving an item from a collection.
+     * @returns Retrieved item.
+     */
+    (dataItemId: string, options?: GetDataItemOptions | undefined): Promise<DataItem & DataItemNonNullableFields>;
+}
+declare function removeDataItem$1(httpClient: HttpClient): RemoveDataItemSignature;
+interface RemoveDataItemSignature {
+    /**
+     * Removes an item from a collection.
+     *
+     *
+     * If any items in other collections reference the removed item in reference or multi-reference fields, those fields are cleared.
+     *
+     * > **Note:**
+     * > Once an item has been removed from a collection, it can't be restored.
+     * @param - ID of the item to remove.
+     * @param - Options for removing an item from a collection.
+     */
+    (dataItemId: string, options: RemoveDataItemOptions): Promise<RemoveDataItemResponse & RemoveDataItemResponseNonNullableFields>;
+}
+declare function truncateDataItems$1(httpClient: HttpClient): TruncateDataItemsSignature;
+interface TruncateDataItemsSignature {
+    /**
+     * Removes all items from a collection.
+     *
+     *
+     * If any items in other collections reference the removed items in reference or multi-reference fields, those fields are cleared.
+     *
+     * > **Note:**
+     * > Once items have been removed from a collection, they can't be restored.
+     * @param - Options for truncating data items from a collection.
+     */
+    (options: TruncateDataItemsOptions): Promise<void>;
+}
+declare function queryDataItems$1(httpClient: HttpClient): QueryDataItemsSignature;
+interface QueryDataItemsSignature {
+    /**
+     * Creates a query to retrieve items from a database collection.
+     *
+     * The `queryDataItems()` function builds a query to retrieve data items from a collection and returns a `DataItemsQueryBuilder` object.
+     *
+     * The returned object contains the query definition which is typically used to run the query using the `find()` function.
+     *
+     * You can refine the query by chaining `DataItemsQueryBuilder` functions onto the query. `DataItemsQueryBuilder` functions enable you to sort, filter, and control the results that `queryDataItems()` returns.
+     *
+     * The `queryDataItems()` function runs with the following `DataItemsQueryBuilder` defaults that you can override:
+     *
+     * + `skip`: 0
+     * + `limit`: 50
+     * + `descending`: by `_createdDate`
+     *
+     * The functions that are chained to `queryDataItems()` are applied in the order they are called. For example, if you sort on an `age` field in ascending order and then on a `name` field in descending order, the results are sorted first by the age of the items and then, if there are multiple results with the same age, the items are sorted by name in descending order, per age value.
+     *
+     * If the collection that you are querying has references to other collections, by default the data from referenced collections is not retrieved. To get the data from referenced items, specify them in the `options.includeReferencedItems` parameter.
+     *
+     * > **Note**: When calling `queryDataItems()` following an update to your collection, the data retrieved may not contain the most recent changes. If you need the most up-to-date data, set `options.consistentRead` to `true`.
+     *
+     *
+     * @param - Options for querying data items.
+     */
+    (options: QueryDataItemsOptions): DataItemsQueryBuilder;
+}
+declare function aggregateDataItems$1(httpClient: HttpClient): AggregateDataItemsSignature;
+interface AggregateDataItemsSignature {
+    /**
+     * Runs an aggregation on a data collection and returns the resulting list of items.
+     *
+     *
+     * An aggregation enables you to perform certain calculations on your collection data, or on groups of items that you define, to retrieve meaningful summaries.
+     * You can also add paging, filtering, and sorting preferences to your aggregation to retrieve exactly what you need.
+     * @param - Options for running an aggregation.
+     */
+    (options?: AggregateDataItemsOptions | undefined): Promise<AggregateDataItemsResponse>;
+}
+declare function countDataItems$1(httpClient: HttpClient): CountDataItemsSignature;
+interface CountDataItemsSignature {
+    /**
+     * Counts the number of items in a data collection that match the provided filtering preferences.
+     *
+     * > **Note**: When calling `countDataItems()` following an update to your collection, the result returned may not reflect the most recent changes. If you need the most up-to-date data, set `options.consistentRead` to `true`.
+     * @param - Options for counting the number of items in a data collection.
+     */
+    (options?: CountDataItemsOptions | undefined): Promise<CountDataItemsResponse & CountDataItemsResponseNonNullableFields>;
+}
+declare function queryDistinctValues$1(httpClient: HttpClient): QueryDistinctValuesSignature;
+interface QueryDistinctValuesSignature {
+    /**
+     * Retrieves a list of distinct values for a given field in all items that match a query, without duplicates.
+     *
+     *
+     * As with `queryDataItems()`, this endpoint retrieves items based on the filtering, sorting, and paging preferences you provide.
+     * However, `queryDistinctValues()` doesn't return all of the full items that match the query.
+     * Rather, it returns all unique values of the field you specify in `options.fieldName` for items that match the query.
+     * If more than one item has the same value for that field, that value appears only once.
+     *
+     * For more details on using queries, see [API Query Language](https://dev.wix.com/api/rest/getting-started/api-query-language).
+     *
+     * > **Note**: When calling `queryDistinctValues()` following an update to your collection, the data retrieved may not reflect the most recent changes. If you need the most up-to-date data, set `options.consistentRead` to `true`.
+     * @param - Options for querying distinct values.
+     */
+    (options?: QueryDistinctValuesOptions | undefined): Promise<QueryDistinctValuesResponse>;
+}
+declare function bulkInsertDataItems$1(httpClient: HttpClient): BulkInsertDataItemsSignature;
+interface BulkInsertDataItemsSignature {
+    /**
+     * Adds multiple items to a collection.
+     *
+     *
+     * When each item is inserted into a collection, its ID is automatically assigned a random value.
+     * You can optionally provide your own ID when inserting the item. If you specify an ID that already exists in the collection, the insertion will fail.
+     * @param - Options for adding multiple items to a collection.
+     */
+    (options?: BulkInsertDataItemsOptions | undefined): Promise<BulkInsertDataItemsResponse & BulkInsertDataItemsResponseNonNullableFields>;
+}
+declare function bulkUpdateDataItems$1(httpClient: HttpClient): BulkUpdateDataItemsSignature;
+interface BulkUpdateDataItemsSignature {
+    /**
+     * Updates multiple items in a collection.
+     *
+     *
+     * This function replaces each specified data item's existing data with the payload provided in the request.
+     *
+     * Each item in the request must include an ID. If an item is found in the specified collection with
+     * the same ID, that item is updated. If the collection doesn't contain an item with that ID, the update fails.
+     *
+     * When an item is updated, its `data._updatedDate` field is changed to the current date and time.
+     *
+     * > **Note:**
+     * > After each item is updated, it only contains the fields included in the request. If the existing item has fields with values and those fields
+     * > aren't included in the updated item, their values are lost.
+     * @param - Options for updating multiple items in a collection.
+     */
+    (options?: BulkUpdateDataItemsOptions | undefined): Promise<BulkUpdateDataItemsResponse & BulkUpdateDataItemsResponseNonNullableFields>;
+}
+declare function bulkSaveDataItems$1(httpClient: HttpClient): BulkSaveDataItemsSignature;
+interface BulkSaveDataItemsSignature {
+    /**
+     * Inserts or updates multiple items in a collection.
+     *
+     *
+     * This function inserts or updates each item provided, depending on whether it already exists in the collection. For each item:
+     *
+     * + If you don't provide an ID, a new item is created.
+     *
+     * + If you provide an ID that doesn't exist in the collection, a new item is created with that ID.
+     *
+     * + If an item with the ID you provide already exists in the collection, that item is updated. When an item is updated, its `data._updatedDate` field is changed to the current date and time.
+     *
+     * > **Note:** When you provide an item with an ID that already exists in the collection, the item you provide completely replaces the existing item with that ID.
+     * > This means that all of the item's previous fields and values are lost.
+     * @param - Options for saving multiple items in a collection.
+     */
+    (options?: BulkSaveDataItemsOptions | undefined): Promise<BulkSaveDataItemsResponse & BulkSaveDataItemsResponseNonNullableFields>;
+}
+declare function bulkRemoveDataItems$1(httpClient: HttpClient): BulkRemoveDataItemsSignature;
+interface BulkRemoveDataItemsSignature {
+    /**
+     * Removes multiple items from a collection.
+     *
+     *
+     * If any items in other collections reference the removed items in reference or multi-reference fields, those fields are cleared.
+     *
+     * > **Note:** Once an item has been removed from a collection, it can't be restored.
+     * @param - Options for removing multiple items from a collection.
+     */
+    (options: BulkRemoveDataItemsOptions): Promise<BulkRemoveDataItemsResponse & BulkRemoveDataItemsResponseNonNullableFields>;
+}
+declare function queryReferencedDataItems$1(httpClient: HttpClient): QueryReferencedDataItemsSignature;
+interface QueryReferencedDataItemsSignature {
+    /**
+     * Retrieves the full items referenced in the specified field of an item.
+     *
+     *
+     * Reference and multi-reference fields refer to items in different collections.
+     * Use this function to retrieve the full details of the referenced items themselves.
+     *
+     * For example, suppose you have a **Movies** collection with an **Actors** field that contains references to items in a **People** collection.
+     * Querying the **Movies** collection using `queryReferencedDataItems()` returns the relevant **People** items referenced in the **Actors** field of the specified **Movie** item.
+     * This gives you information from the **People** collection about each of the actors in the specified movie.
+     *
+     * > **Note**: When calling `queryReferencedDataItems()` following an update to your collection, the data retrieved may not contain the most recent changes. If you need the most up-to-date data, set `options.consistentRead` to `true`.
+     * @param - Options for querying referenced data items.
+     */
+    (options?: QueryReferencedDataItemsOptions | undefined): Promise<QueryReferencedDataItemsResponse & QueryReferencedDataItemsResponseNonNullableFields>;
+}
+declare function isReferencedDataItem$1(httpClient: HttpClient): IsReferencedDataItemSignature;
+interface IsReferencedDataItemSignature {
+    /**
+     * Checks whether a field in a referring item contains a reference to a specified item.
+     *
+     * > **Note**: When calling `isReferencedDataItem()` following an update to your collection, the result returned may not reflect the most recent changes. If you need the most up-to-date data, set `options.consistentRead` to `true`.
+     * @param - Options for checking whether a field contains a reference to an item.
+     */
+    (options?: IsReferencedDataItemOptions | undefined): Promise<IsReferencedDataItemResponse & IsReferencedDataItemResponseNonNullableFields>;
+}
+declare function insertDataItemReference$1(httpClient: HttpClient): InsertDataItemReferenceSignature;
+interface InsertDataItemReferenceSignature {
+    /**
+     * Inserts a reference in the specified field in an item in a collection.
+     *
+     *
+     * A reference in `options.dataItemReference` specifies a referring item's ID, the field in which to insert the reference, and the ID of the referenced item.
+     * @param - Options for inserting a reference.
+     */
+    (options?: InsertDataItemReferenceOptions | undefined): Promise<InsertDataItemReferenceResponse & InsertDataItemReferenceResponseNonNullableFields>;
+}
+declare function removeDataItemReference$1(httpClient: HttpClient): RemoveDataItemReferenceSignature;
+interface RemoveDataItemReferenceSignature {
+    /**
+     * Removes the specified reference from the specified field.
+     * @param - Options for removing a reference.
+     */
+    (options: RemoveDataItemReferenceOptions): Promise<RemoveDataItemReferenceResponse & RemoveDataItemReferenceResponseNonNullableFields>;
+}
+declare function bulkInsertDataItemReferences$1(httpClient: HttpClient): BulkInsertDataItemReferencesSignature;
+interface BulkInsertDataItemReferencesSignature {
+    /**
+     * Inserts one or more references in the specified fields of items in a collection.
+     *
+     *
+     * This endpoint adds one or more references to a collection.
+     * Each new reference in `options.dataItemReferences` specifies a referring item's ID, the field in which to insert the reference, and the ID of the referenced item.
+     * @param - Options for inserting one or more references.
+     */
+    (options?: BulkInsertDataItemReferencesOptions | undefined): Promise<BulkInsertDataItemReferencesResponse & BulkInsertDataItemReferencesResponseNonNullableFields>;
+}
+declare function bulkRemoveDataItemReferences$1(httpClient: HttpClient): BulkRemoveDataItemReferencesSignature;
+interface BulkRemoveDataItemReferencesSignature {
+    /**
+     * Removes one or more references.
+     * @param - Options for removing one or more references.
+     */
+    (options: BulkRemoveDataItemReferencesOptions): Promise<BulkRemoveDataItemReferencesResponse & BulkRemoveDataItemReferencesResponseNonNullableFields>;
+}
+declare function replaceDataItemReferences$1(httpClient: HttpClient): ReplaceDataItemReferencesSignature;
+interface ReplaceDataItemReferencesSignature {
+    /**
+     * Replaces references in a specified field of a specified data item.
+     *
+     *
+     * This function replaces the existing reference or references contained in the field specified in `options.referringItemFieldName` within the data item specified in `options.referringItemId`.
+     * The function removes existing references and in their place it adds references to the items specified in `options.newReferencedItemIds`.
+     *
+     * > **Note:** If you pass an empty array in `options.newReferencedItemIds`, all existing references are removed.
+     * @param - Options for replacing references.
+     */
+    (options?: ReplaceDataItemReferencesOptions | undefined): Promise<ReplaceDataItemReferencesResponse & ReplaceDataItemReferencesResponseNonNullableFields>;
+}
 declare const onDataItemCreated$1: EventDefinition<DataItemCreatedEnvelope, "wix.data.v2.data_item_created">;
 declare const onDataItemUpdated$1: EventDefinition<DataItemUpdatedEnvelope, "wix.data.v2.data_item_updated">;
 declare const onDataItemDeleted$1: EventDefinition<DataItemDeletedEnvelope, "wix.data.v2.data_item_deleted">;
@@ -3639,12 +4077,21 @@ type _publicReplaceDataItemReferencesType = typeof replaceDataItemReferences$1;
 declare const replaceDataItemReferences: ReturnType<typeof createRESTModule$1<_publicReplaceDataItemReferencesType>>;
 
 type _publicOnDataItemCreatedType = typeof onDataItemCreated$1;
+/**
+ * Triggered when a data item is inserted.
+ */
 declare const onDataItemCreated: ReturnType<typeof createEventModule<_publicOnDataItemCreatedType>>;
 
 type _publicOnDataItemUpdatedType = typeof onDataItemUpdated$1;
+/**
+ * Triggered when a data item is updated.
+ */
 declare const onDataItemUpdated: ReturnType<typeof createEventModule<_publicOnDataItemUpdatedType>>;
 
 type _publicOnDataItemDeletedType = typeof onDataItemDeleted$1;
+/**
+ * Triggered when a data item is deleted.
+ */
 declare const onDataItemDeleted: ReturnType<typeof createEventModule<_publicOnDataItemDeletedType>>;
 
 type context$1_ACTION = ACTION;
@@ -4023,9 +4470,51 @@ interface ListIndexesOptions {
     paging?: Paging;
 }
 
-declare function createIndex$1(httpClient: HttpClient): (dataCollectionId: string, index: Index) => Promise<Index & IndexNonNullableFields>;
-declare function dropIndex$1(httpClient: HttpClient): (dataCollectionId: string, indexName: string) => Promise<void>;
-declare function listIndexes$1(httpClient: HttpClient): (dataCollectionId: string, options?: ListIndexesOptions) => Promise<ListIndexesResponse & ListIndexesResponseNonNullableFields>;
+declare function createIndex$1(httpClient: HttpClient): CreateIndexSignature;
+interface CreateIndexSignature {
+    /**
+     * Creates an index for a data collection.
+     *
+     * The index can't be used immediately, as the process of generating the index takes time.
+     * You can check whether your index is ready using `listIndexes()`.
+     *
+     * Note that when an index fails to create, the failed index still occupies a slot.
+     * To remove the failed index and free up the slot for a new index, use `dropIndex()`.
+     * @param - ID of the data collection for which to generate the index.
+     * @param - Details of the index to be created.
+     * @param - Options for creating an index.
+     * @returns Details of the index being generated.
+     */
+    (dataCollectionId: string, index: Index): Promise<Index & IndexNonNullableFields>;
+}
+declare function dropIndex$1(httpClient: HttpClient): DropIndexSignature;
+interface DropIndexSignature {
+    /**
+     * Removes an index from a data collection.
+     *
+     * The process of dropping an index from a collection takes time.
+     * You can check whether your index has been dropped by calling `listIndexes()`.
+     * @param - ID of the data collection for which the index to be dropped is defined.
+     * @param - Name of the index to drop.
+     * @param - Options for dropping an index.
+     */
+    (dataCollectionId: string, indexName: string): Promise<void>;
+}
+declare function listIndexes$1(httpClient: HttpClient): ListIndexesSignature;
+interface ListIndexesSignature {
+    /**
+     * Lists all indexes defined for a data collection.
+     *
+     * When an index's status is `ACTIVE`, it is ready to use.
+     * While it is still being created, its status is `BUILDING`.
+     *
+     * When an index's status is `DROPPED`, it has been dropped successfully.
+     * While it is still in the process of being removed, its status is `DROPPING`.
+     * @param - ID of the data collection for which to list indexes.
+     * @param - Options for retrieving a list of indexes.
+     */
+    (dataCollectionId: string, options?: ListIndexesOptions | undefined): Promise<ListIndexesResponse & ListIndexesResponseNonNullableFields>;
+}
 
 declare function createRESTModule<T extends RESTFunctionDescriptor>(descriptor: T, elevated?: boolean): BuildRESTFunction<T> & T;