@arrai-innovations/reactive-helpers 20.1.2 → 21.0.0

package/types/use/listCalculated.d.ts

@@ -1,9 +1,73 @@
+/**
+ * This module provides a Vue Composition API composable function for dynamically calculating properties in lists
+ * based on complex business logic. It integrates with list management systems to apply user-defined rules
+ * that calculate new properties based on changes in list items or related data. This is particularly useful for
+ * applications that need to display derived data without altering the original source objects in the list.
+ *
+ * @module use/listCalculated.js
+ */
+/**
+ * Defines rules for dynamically calculating new properties for objects in a list. Each rule is a function that takes an
+ *  object from the list, optionally its related objects, and previously calculated properties to compute a new
+ *  property. These functions are reactive and re-evaluate when underlying dependencies change.
+ *
+ * @typedef {{
+ *     [rule: string]: (
+ *         object: import('../use/objectInstance.js').ExistingCrudObject,
+ *         relatedObject: {
+ *             [rule: string]: any,
+ *         },
+ *         calculatedObjects: {
+ *             [rule: string]: import('vue').ComputedRef<any>,
+ *         }
+ *     ) => any,
+ * }}  ListCalculatedRules
+ */
+/**
+ * The raw state for a list calculated.
+ *
+ * @typedef {object} ListCalculatedRawState - The raw state for a list calculated property.
+ * @property {{[pk: string]: {[rule: string]: import('vue').ComputedRef<any>}}} calculatedObjects - The calculated objects.
+ * @property {ListCalculatedRules} calculatedObjectsRules - The rules for the calculated objects.
+ * @property {boolean} calculatedObjectsParentStateObjectsWatchRunning - Whether the parent state objects watch is running.
+ * @property {boolean} calculatedObjectsWatchRunning - Whether the calculated objects watch is running.
+ * @property {import('vue').ComputedRef<boolean>} calculatedRunning - Whether the calculated properties are running.
+ * @property {import('vue').ComputedRef<boolean>} running - Whether the list is running.
+ * @private
+ */
+/**
+ * The raw parent state for a list calculated.
+ *
+ * @typedef {(
+ *     import('./listInstance.js').ListInstanceRawState &
+ *     Partial<import('./listSubscription.js').ListSubscriptionRawState> &
+ *     Partial<import('./listRelated.js').ListRelatedRawState>
+ * )} ListCalculatedParentRawState
+ */
+/**
+ * The state for a list calculated property.
+ *
+ * @typedef {import('vue').UnwrapNestedRefs<
+ *     ListCalculatedParentRawState &
+ *     ListCalculatedRawState
+ * >} ListCalculatedState
+ */
+/**
+ * Represents a combined reactive state that includes properties from list related,
+ *  subscription, and instance modules.
+ *
+ * @typedef {import('vue').UnwrapNestedRefs<(
+ *     import('./listInstance.js').ListInstanceRawState &
+ *     Partial<import('./listSubscription.js').ListSubscriptionRawState> &
+ *     Partial<import('./listRelated.js').ListRelatedRawState>
+ * )>} ListCalculatedParentState
+ */
 /**
  * The options to create a list calculated composition function.
  *
  * @typedef {object} ListCalculatedOptions - Options to configure the behavior of the list calculated properties.
  * @property {ListCalculatedParentState} parentState - The parent state that interacts with the calculated objects.
- * @property {ListCalculatedRules} calculatedObjectsRules - A reactive reference to rules used for dynamic calculations
+ * @property {import('vue').Ref<ListCalculatedRules>} calculatedObjectsRules - A reactive reference to rules used for dynamic calculations
  *  within list objects. Proper setup of this reference ensures that updates are managed reactively, including deep
  *  property changes.
  */
@@ -13,8 +77,7 @@
  * @typedef {object} ListCalculatedProperties
  * @property {ListCalculatedState} state - The state for the list calculated property.
  * @property {ListCalculatedParentState} parentState - The parent state object.
- * @property {import('./watchesRunning.js').WatchesRunning} watchesRunning - The watches running.
- * @property {import('vue').EffectScope} effectScope - The effect scope for the list calculated property.
+ * @property {() => void} stop - Stops composition's effects and cleans up resources.
  */
 /**
  * The instance of `useListCalculated`.
@@ -90,58 +153,18 @@ export function useListCalculateds(listCalculatedArgs: {
  *  list, facilitating real-time updates and complex dependency management across multiple components.
  */
 export function useListCalculated({ parentState, calculatedObjectsRules }: ListCalculatedOptions): ListCalculated;
-/**
- * - Options to configure the behavior of the list calculated properties.
- */
-export type ListCalculatedOptions = {
-    /**
-     * - The parent state that interacts with the calculated objects.
-     */
-    parentState: ListCalculatedParentState;
-    /**
-     * - A reactive reference to rules used for dynamic calculations
-     * within list objects. Proper setup of this reference ensures that updates are managed reactively, including deep
-     * property changes.
-     */
-    calculatedObjectsRules: ListCalculatedRules;
-};
-/**
- * The properties for the list computed composition function.
- */
-export type ListCalculatedProperties = {
-    /**
-     * - The state for the list calculated property.
-     */
-    state: ListCalculatedState;
-    /**
-     * - The parent state object.
-     */
-    parentState: ListCalculatedParentState;
-    /**
-     * - The watches running.
-     */
-    watchesRunning: import("./watchesRunning.js").WatchesRunning;
-    /**
-     * - The effect scope for the list calculated property.
-     */
-    effectScope: import("vue").EffectScope;
-};
-/**
- * The instance of `useListCalculated`.
- */
-export type ListCalculated = ListCalculatedProperties;
 /**
  * Defines rules for dynamically calculating new properties for objects in a list. Each rule is a function that takes an
  *  object from the list, optionally its related objects, and previously calculated properties to compute a new
  *  property. These functions are reactive and re-evaluate when underlying dependencies change.
  */
-export type ListCalculatedRules = import("vue").Ref<{
-    [rule: string]: (object: import("./listInstance.js").ListObject, relatedObject: {
+export type ListCalculatedRules = {
+    [rule: string]: (object: import("../use/objectInstance.js").ExistingCrudObject, relatedObject: {
         [rule: string]: any;
     }, calculatedObjects: {
         [rule: string]: import("vue").ComputedRef<any>;
     }) => any;
-}>;
+};
 /**
  * - The raw state for a list calculated property.
  */
@@ -169,11 +192,11 @@ export type ListCalculatedRawState = {
     /**
      * - Whether the calculated properties are running.
      */
-    calculatedRunning: boolean;
+    calculatedRunning: import("vue").ComputedRef<boolean>;
     /**
      * - Whether the list is running.
      */
-    running: import("vue").Ref<boolean>;
+    running: import("vue").ComputedRef<boolean>;
 };
 /**
  * The raw parent state for a list calculated.
@@ -188,4 +211,39 @@ export type ListCalculatedState = import("vue").UnwrapNestedRefs<ListCalculatedP
  *  subscription, and instance modules.
  */
 export type ListCalculatedParentState = import("vue").UnwrapNestedRefs<(import("./listInstance.js").ListInstanceRawState & Partial<import("./listSubscription.js").ListSubscriptionRawState> & Partial<import("./listRelated.js").ListRelatedRawState>)>;
-//# sourceMappingURL=listCalculated.d.ts.map
+/**
+ * - Options to configure the behavior of the list calculated properties.
+ */
+export type ListCalculatedOptions = {
+    /**
+     * - The parent state that interacts with the calculated objects.
+     */
+    parentState: ListCalculatedParentState;
+    /**
+     * - A reactive reference to rules used for dynamic calculations
+     * within list objects. Proper setup of this reference ensures that updates are managed reactively, including deep
+     * property changes.
+     */
+    calculatedObjectsRules: import("vue").Ref<ListCalculatedRules>;
+};
+/**
+ * The properties for the list computed composition function.
+ */
+export type ListCalculatedProperties = {
+    /**
+     * - The state for the list calculated property.
+     */
+    state: ListCalculatedState;
+    /**
+     * - The parent state object.
+     */
+    parentState: ListCalculatedParentState;
+    /**
+     * - Stops composition's effects and cleans up resources.
+     */
+    stop: () => void;
+};
+/**
+ * The instance of `useListCalculated`.
+ */
+export type ListCalculated = ListCalculatedProperties;

package/types/use/listFilter.d.ts

@@ -1,5 +1,13 @@
 /**
- * @typedef {import('vue').Ref<import('./listInstance.js').ListObject>[]} ObjectsInOrderRefs
+ * Provides reactive filtering functionality for lists within a Vue application. This composable
+ * supports defining dynamic inclusion and exclusion criteria to control the visibility of list items
+ * based on user-defined rules. It's particularly useful in scenarios where list contents need to be
+ * dynamically adjusted without modifying the source data.
+ *
+ * @module use/listFilter.js
+ */
+/**
+ * @typedef {import('vue').Ref<import('../use/objectInstance.js').ExistingCrudObject>[]} ObjectsInOrderRefs
  */
 /**
  * @typedef {Function} ListFilterAllowedFilter - A function that returns true if an item should be included.
@@ -14,11 +22,6 @@
  * @typedef {object} ListFilterRawState
  * @property {ListFilterAllowedFilter} [allowedFilter] - Function to determine if an item should be included based on custom logic.
  * @property {ListFilterExcludedFilter} [excludedFilter] - Function to determine if an item should be excluded based on custom logic.
- * @property {object} inResults - A map of items to boolean values indicating filter results.
- * @property {boolean} objectsWatchRunning - Flag indicating if the object watch is active.
- * @property {boolean} resultsWatchRunning - Flag indicating if the results watch is active.
- * @property {boolean} running - Flag indicating if any part of the filter logic is currently processing.
- * @property {boolean} orderWatchRunning - Flag indicating if the order watch is active.
  */
 /**
  *
@@ -59,7 +62,7 @@
  * @typedef {object} ListFilterProperties
  * @property {ListFilterState} state - The reactive state managing the filter logic and results.
  * @property {ListFilterParentState} parentState - The state of the list being filtered.
- * @property {import('vue').EffectScope} effectScope - Scoped reactivity for this filter instance.
+ * @property {() => void} stop - A function to stop the effect scope and clean up resources.
  */
 /**
  * Represents an instance of a list filter, including its state and associated Vue composition API utilities.
@@ -110,7 +113,7 @@ export function useListFilters(listFilterArgs: {
  * @returns {ListFilter} A fully configured list filter instance, providing reactive filtered results.
  */
 export function useListFilter({ parentState, allowedFilter, excludedFilter }: ListFilterOptions): ListFilter;
-export type ObjectsInOrderRefs = import("vue").Ref<import("./listInstance.js").ListObject>[];
+export type ObjectsInOrderRefs = import("vue").Ref<import("../use/objectInstance.js").ExistingCrudObject>[];
 /**
  * - A function that returns true if an item should be included.
  */
@@ -132,26 +135,6 @@ export type ListFilterRawState = {
      * - Function to determine if an item should be excluded based on custom logic.
      */
     excludedFilter?: ListFilterExcludedFilter;
-    /**
-     * - A map of items to boolean values indicating filter results.
-     */
-    inResults: object;
-    /**
-     * - Flag indicating if the object watch is active.
-     */
-    objectsWatchRunning: boolean;
-    /**
-     * - Flag indicating if the results watch is active.
-     */
-    resultsWatchRunning: boolean;
-    /**
-     * - Flag indicating if any part of the filter logic is currently processing.
-     */
-    running: boolean;
-    /**
-     * - Flag indicating if the order watch is active.
-     */
-    orderWatchRunning: boolean;
 };
 export type ListFilterParentRawState = (import("./listInstance.js").ListInstanceRawState & Partial<import("./listSubscription.js").ListSubscriptionRawState> & Partial<import("./listRelated.js").ListRelatedRawState> & Partial<import("./listCalculated.js").ListCalculatedRawState>);
 /**
@@ -192,12 +175,11 @@ export type ListFilterProperties = {
      */
     parentState: ListFilterParentState;
     /**
-     * - Scoped reactivity for this filter instance.
+     * - A function to stop the effect scope and clean up resources.
      */
-    effectScope: import("vue").EffectScope;
+    stop: () => void;
 };
 /**
  * Represents an instance of a list filter, including its state and associated Vue composition API utilities.
  */
 export type ListFilter = ListFilterProperties;
-//# sourceMappingURL=listFilter.d.ts.map

package/types/use/listInstance.d.ts

@@ -20,59 +20,95 @@
  *  function.
  * @property {import('../config/listCrud.js').CrudListSubscribeFn} [handlers.subscribe] - Provide the implementation for the
  *  subscribe function.
- * @property {import('vue').Ref<boolean>|boolean} keepOldPages - If true, pages will not be cleared when defaultPageCallback is called.
  */
 /**
  * The objects by pk.
  *
- * @typedef {{[pk: string]: ListObject}} ObjectsByPk
+ * @typedef {{[pk: string]: import('../use/objectInstance.js').ExistingCrudObject}} ObjectsByPk
  */
 /**
  * The objects in order, based on .order & .objects.
  *
- * @typedef {import('vue').ComputedRef<ListObject[]>} ObjectsInOrder
+ * @typedef {import('vue').ComputedRef<import('../use/objectInstance.js').ExistingCrudObject[]>} ObjectsInOrder
  */
 /**
  * The order of the objects in the list.
  *
  * @typedef {import('vue').ComputedRef<string[]>} ListOrder
  */
+/**
+ * @typedef {object} ListInstanceRawStateCrud
+ * @property {import('vue').Reactive<import('../config/objectCrud.js').TargetArgs|{}>} args - The arguments to be passed to the crud handlers.
+ * @property {import('../config/listCrud.js').CrudListFn} list - The list function.
+ * @property {import('../config/listCrud.js').CrudListSubscribeFn} subscribe - The subscribe function.
+ * @property {import('../config/listCrud.js').CrudBulkDeleteFn} bulkDelete - The bulk delete function.
+ * @property {import('../config/listCrud.js').CrudExecuteActionFn} executeAction - The execute action function.
+ */
+/**
+ * @typedef {Map<string, import('vue').Reactive<import('../use/objectInstance.js').ExistingCrudObject>>} ObjectsMap
+ */
+/**
+ * @typedef {object} PaginateInfo
+ * @property {number} [totalRecords] - The total records.
+ * @property {number} [totalPages] - The total pages.
+ * @property {number} [perPage] - The per page.
+ * @property {number} [page] - The page you are giving us results for.
+ */
+/**
+ * @typedef {{ [key: string]: number | string }} ColumnTotals
+ */
 /**
  * The raw state object for the list instance, defining the reactive properties and their types.
  *
- * @typedef {object} ListInstanceRawState
- * @property {object} crud - CRUD handlers and their configurations for the list.
- * @property {object} crud.args - Arguments for the CRUD handlers.
- * @property {Function} [crud.list] - Function to list objects.
+ * @typedef {object} ListInstanceRawMyState
+ * @property {import('vue').Reactive<ListInstanceRawStateCrud>} crud - CRUD handlers and their configurations for the list.
  * @property {string} pkKey - The primary key field for the list objects.
  * @property {object} params - Arguments passed to the server for listing operations.
+ * @property {ObjectsMap} objectsMap - The map of objects stored by their pks.
  * @property {ObjectsByPk} objects - The list objects stored by their pks.
- * @property {boolean} running - Indicates if there are ongoing reactive updates.
- * @property {Readonly<import('vue').Ref<boolean>>} [loading] - Indicates if the list is currently loading.
- * @property {Readonly<import('vue').Ref<boolean>>} errored - Indicates if an error occurred during the last operation.
- * @property {Readonly<import('vue').Ref<Error|null>>} error - The last error encountered.
  * @property {ListOrder} order - The order of objects in the list.
  * @property {ObjectsInOrder} objectsInOrder - The objects in the order specified by the list.
+ * @property {import('vue').ShallowReactive<PaginateInfo>} paginateInfo - Pagination information for the list.
+ * @property {import('vue').ShallowReactive<ColumnTotals>} columnTotals - Column totals for the list.
+ */
+/**
+ * @typedef {ListInstanceRawMyState & Pick<import('./loadingError.js').LoadingErrorStatus, "loading" | "error" | "errored">} ListInstanceRawState
  */
 /**
  * Defines the reactive state used by the list instance.
  *
  * @typedef {import('vue').UnwrapNestedRefs<ListInstanceRawState>} ListInstanceState
  */
+/**
+ * @typedef {(newObjects: import('../use/objectInstance.js').ExistingCrudObject[]) => void} PushObjectsFn
+ */
+/**
+ * @typedef {() => void} ClearListFn
+ */
+/**
+ * @typedef {(info: PaginateInfo) => void} SetPaginateInfoFn
+ */
+/**
+ * @typedef {(total: ColumnTotals) => void} SetColumnTotalsFn
+ */
 /**
  * Defines the methods provided by the list instance for managing objects in the list.
  *
- * @typedef {object} ListInstanceFunctions
- * @property {(newObjects: ListObject[]) => void} defaultPageCallback - Handles new or updated objects, respecting the keepOldPages setting.
- * @property {(newObjects: ListObject[]) => void} pageCallback - Customizable callback for handling new objects per page.
- * @property {(object: ListObject) => void} addListObject - Adds an object to the list.
- * @property {(object: ListObject) => void} updateListObject - Updates an object in the list.
+ * @typedef {object} ListInstanceMyFunctions
+ * @property {PushObjectsFn} pushObjects - Customizable callback for handling new objects per page.
+ * @property {(object: import('../use/objectInstance.js').ExistingCrudObject) => void} addListObject - Adds an object to the list.
+ * @property {(object: import('../use/objectInstance.js').ExistingCrudObject) => void} updateListObject - Updates an object in the list.
  * @property {(objectId: string) => void} deleteListObject - Deletes an object from the list by pk.
  * @property {() => void} clearList - Clears all objects and errors from the list.
  * @property {() => string} getFakePk - Generates a unique fake pk for use within the list.
  * @property {() => import('../utils/cancellablePromise.js').MaybeCancellablePromise<boolean|never>} list - Initiates a fetch to retrieve objects according to the CRUD configuration, returning a promise to a boolean indicating success.
- * @property {() => Promise<boolean>} bulkDelete - Initiates a bulk delete operation on all objects in the list, returning a promise to a boolean indicating success.
+ * @property {(args: {pks?: string[]}) => Promise<boolean>} bulkDelete - Deletes objects from the list by pk, returning a promise to a boolean indicating success.
  * @property {() => Promise<object|string|false>} executeAction - Initiates an action on all objects in the list, returning the response, or false if the action failed.
+ * @property {(info: PaginateInfo) => void} setPaginateInfo - The method to update pagination information.
+ * @property {(total: ColumnTotals) => void} setColumnTotals - The method to update column totals.
+ */
+/**
+ * @typedef {ListInstanceMyFunctions & Pick<import('./loadingError.js').LoadingErrorStatus, "clearError">} ListInstanceFunctions
  */
 /**
  * Helper type to facilitate the combination of state and functions into a single type.
@@ -145,20 +181,14 @@ export function useListInstances(listInstanceArgs: {
  * @param {ListInstanceOptions} options - Specifies the configuration options for creating a list instance, including
  *  properties for CRUD operations and UI behaviors like page persistence.
  * @returns {ListInstance} The list instance.
- * @throws {ListInstanceError} If the props or keepOldPages are missing.
+ * @throws {ListInstanceError} If the props are missing.
  */
-export function useListInstance({ props, handlers, keepOldPages }: ListInstanceOptions): ListInstance;
+export function useListInstance({ props, handlers }: ListInstanceOptions): ListInstance;
 /**
  * A composable function for managing a list of objects.
  *
  * @module use/listInstance.js
  */
-/**
- * Defines the structure for the objects stored within the list, each identified by a unique pk and capable of
- *  holding various key-value pairs.
- *
- * @typedef {{pk: string, [key: string]: any}} ListObject
- */
 /**
  * Defines a custom error class specific to list instance operations, encapsulating details about errors that occur
  *  during list manipulation and processing.
@@ -207,36 +237,73 @@ export type ListInstanceOptions = {
         executeAction?: import("../config/listCrud.js").CrudExecuteActionFn;
         subscribe?: import("../config/listCrud.js").CrudListSubscribeFn;
     };
-    /**
-     * - If true, pages will not be cleared when defaultPageCallback is called.
-     */
-    keepOldPages: import("vue").Ref<boolean> | boolean;
 };
 /**
  * The objects by pk.
  */
 export type ObjectsByPk = {
-    [pk: string]: ListObject;
+    [pk: string]: import("../use/objectInstance.js").ExistingCrudObject;
 };
 /**
  * The objects in order, based on .order & .objects.
  */
-export type ObjectsInOrder = import("vue").ComputedRef<ListObject[]>;
+export type ObjectsInOrder = import("vue").ComputedRef<import("../use/objectInstance.js").ExistingCrudObject[]>;
 /**
  * The order of the objects in the list.
  */
 export type ListOrder = import("vue").ComputedRef<string[]>;
+export type ListInstanceRawStateCrud = {
+    /**
+     * - The arguments to be passed to the crud handlers.
+     */
+    args: import("vue").Reactive<import("../config/objectCrud.js").TargetArgs | {}>;
+    /**
+     * - The list function.
+     */
+    list: import("../config/listCrud.js").CrudListFn;
+    /**
+     * - The subscribe function.
+     */
+    subscribe: import("../config/listCrud.js").CrudListSubscribeFn;
+    /**
+     * - The bulk delete function.
+     */
+    bulkDelete: import("../config/listCrud.js").CrudBulkDeleteFn;
+    /**
+     * - The execute action function.
+     */
+    executeAction: import("../config/listCrud.js").CrudExecuteActionFn;
+};
+export type ObjectsMap = Map<string, import("vue").Reactive<import("../use/objectInstance.js").ExistingCrudObject>>;
+export type PaginateInfo = {
+    /**
+     * - The total records.
+     */
+    totalRecords?: number;
+    /**
+     * - The total pages.
+     */
+    totalPages?: number;
+    /**
+     * - The per page.
+     */
+    perPage?: number;
+    /**
+     * - The page you are giving us results for.
+     */
+    page?: number;
+};
+export type ColumnTotals = {
+    [key: string]: number | string;
+};
 /**
  * The raw state object for the list instance, defining the reactive properties and their types.
  */
-export type ListInstanceRawState = {
+export type ListInstanceRawMyState = {
     /**
      * - CRUD handlers and their configurations for the list.
      */
-    crud: {
-        args: object;
-        list?: Function;
-    };
+    crud: import("vue").Reactive<ListInstanceRawStateCrud>;
     /**
      * - The primary key field for the list objects.
      */
@@ -246,25 +313,13 @@ export type ListInstanceRawState = {
      */
     params: object;
     /**
-     * - The list objects stored by their pks.
-     */
-    objects: ObjectsByPk;
-    /**
-     * - Indicates if there are ongoing reactive updates.
-     */
-    running: boolean;
-    /**
-     * - Indicates if the list is currently loading.
+     * - The map of objects stored by their pks.
      */
-    loading?: Readonly<import("vue").Ref<boolean>>;
+    objectsMap: ObjectsMap;
     /**
-     * - Indicates if an error occurred during the last operation.
-     */
-    errored: Readonly<import("vue").Ref<boolean>>;
-    /**
-     * - The last error encountered.
+     * - The list objects stored by their pks.
      */
-    error: Readonly<import("vue").Ref<Error | null>>;
+    objects: ObjectsByPk;
     /**
      * - The order of objects in the list.
      */
@@ -273,31 +328,40 @@ export type ListInstanceRawState = {
      * - The objects in the order specified by the list.
      */
     objectsInOrder: ObjectsInOrder;
+    /**
+     * - Pagination information for the list.
+     */
+    paginateInfo: import("vue").ShallowReactive<PaginateInfo>;
+    /**
+     * - Column totals for the list.
+     */
+    columnTotals: import("vue").ShallowReactive<ColumnTotals>;
 };
+export type ListInstanceRawState = ListInstanceRawMyState & Pick<import("./loadingError.js").LoadingErrorStatus, "loading" | "error" | "errored">;
 /**
  * Defines the reactive state used by the list instance.
  */
 export type ListInstanceState = import("vue").UnwrapNestedRefs<ListInstanceRawState>;
+export type PushObjectsFn = (newObjects: import("../use/objectInstance.js").ExistingCrudObject[]) => void;
+export type ClearListFn = () => void;
+export type SetPaginateInfoFn = (info: PaginateInfo) => void;
+export type SetColumnTotalsFn = (total: ColumnTotals) => void;
 /**
  * Defines the methods provided by the list instance for managing objects in the list.
  */
-export type ListInstanceFunctions = {
-    /**
-     * - Handles new or updated objects, respecting the keepOldPages setting.
-     */
-    defaultPageCallback: (newObjects: ListObject[]) => void;
+export type ListInstanceMyFunctions = {
     /**
      * - Customizable callback for handling new objects per page.
      */
-    pageCallback: (newObjects: ListObject[]) => void;
+    pushObjects: PushObjectsFn;
     /**
      * - Adds an object to the list.
      */
-    addListObject: (object: ListObject) => void;
+    addListObject: (object: import("../use/objectInstance.js").ExistingCrudObject) => void;
     /**
      * - Updates an object in the list.
      */
-    updateListObject: (object: ListObject) => void;
+    updateListObject: (object: import("../use/objectInstance.js").ExistingCrudObject) => void;
     /**
      * - Deletes an object from the list by pk.
      */
@@ -315,14 +379,25 @@ export type ListInstanceFunctions = {
      */
     list: () => import("../utils/cancellablePromise.js").MaybeCancellablePromise<boolean | never>;
     /**
-     * - Initiates a bulk delete operation on all objects in the list, returning a promise to a boolean indicating success.
+     * - Deletes objects from the list by pk, returning a promise to a boolean indicating success.
      */
-    bulkDelete: () => Promise<boolean>;
+    bulkDelete: (args: {
+        pks?: string[];
+    }) => Promise<boolean>;
     /**
      * - Initiates an action on all objects in the list, returning the response, or false if the action failed.
      */
     executeAction: () => Promise<object | string | false>;
+    /**
+     * - The method to update pagination information.
+     */
+    setPaginateInfo: (info: PaginateInfo) => void;
+    /**
+     * - The method to update column totals.
+     */
+    setColumnTotals: (total: ColumnTotals) => void;
 };
+export type ListInstanceFunctions = ListInstanceMyFunctions & Pick<import("./loadingError.js").LoadingErrorStatus, "clearError">;
 /**
  * Helper type to facilitate the combination of state and functions into a single type.
  */
@@ -333,12 +408,3 @@ export type ListInstanceStateMixIn = {
  * The list instance, combining state management and functional operations for managing a list of objects.
  */
 export type ListInstance = ListInstanceStateMixIn & ListInstanceFunctions;
-/**
- * Defines the structure for the objects stored within the list, each identified by a unique pk and capable of
- *  holding various key-value pairs.
- */
-export type ListObject = {
-    pk: string;
-    [key: string]: any;
-};
-//# sourceMappingURL=listInstance.d.ts.map