@arrai-innovations/reactive-helpers 21.0.1 → 21.1.2

package/types/use/error.d.ts

@@ -6,14 +6,29 @@
  * @typedef {Readonly<ErroredRef>} ErroredReadonlyRef
  */
 /**
- * The error state API.
- *
- * @typedef {object} ErrorStatus
+ * @typedef {object} ErrorProperties
  * @property {ErrorReadonlyRef} error - The error that occurred.
  * @property {ErroredReadonlyRef} errored - Whether an error has occurred.
+ */
+/**
+ * @typedef {object} ErrorFunctions
  * @property {(error: Error) => void} setError - Set the error state.
  * @property {ClearErrorFn} clearError - Clear the error state.
  */
+/**
+ * Proxies can still clear errors but cannot set them directly.
+ *
+ * @typedef {object} ErrorReadOnlyFunctions
+ * @property {ClearErrorFn} clearError - Clear the error state.
+ */
+/**
+ * @typedef {ErrorProperties & ErrorReadOnlyFunctions} ReadonlyErrorStatus
+ */
+/**
+ * The error state API.
+ *
+ * @typedef {ErrorProperties & ErrorFunctions} ErrorStatus
+ */
 /**
  * A composable function for managing error state.
  *
@@ -25,10 +40,7 @@ export type ErrorRef = import("vue").Ref<Error | null>;
 export type ErroredRef = import("vue").Ref<boolean>;
 export type ErrorReadonlyRef = Readonly<ErrorRef>;
 export type ErroredReadonlyRef = Readonly<ErroredRef>;
-/**
- * The error state API.
- */
-export type ErrorStatus = {
+export type ErrorProperties = {
     /**
      * - The error that occurred.
      */
@@ -37,6 +49,8 @@ export type ErrorStatus = {
      * - Whether an error has occurred.
      */
     errored: ErroredReadonlyRef;
+};
+export type ErrorFunctions = {
     /**
      * - Set the error state.
      */
@@ -46,3 +60,17 @@ export type ErrorStatus = {
      */
     clearError: ClearErrorFn;
 };
+/**
+ * Proxies can still clear errors but cannot set them directly.
+ */
+export type ErrorReadOnlyFunctions = {
+    /**
+     * - Clear the error state.
+     */
+    clearError: ClearErrorFn;
+};
+export type ReadonlyErrorStatus = ErrorProperties & ErrorReadOnlyFunctions;
+/**
+ * The error state API.
+ */
+export type ErrorStatus = ErrorProperties & ErrorFunctions;

package/types/use/listCalculated.d.ts

@@ -27,7 +27,7 @@
  * 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 {{[pk: import('../config/commonCrud.js').Pk]: {[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.
@@ -173,7 +173,7 @@ export type ListCalculatedRawState = {
      * - The calculated objects.
      */
     calculatedObjects: {
-        [pk: string]: {
+        [pk: import("../config/commonCrud.js").Pk]: {
             [rule: string]: import("vue").ComputedRef<any>;
         };
     };

package/types/use/listInstance.d.ts

@@ -24,7 +24,7 @@
 /**
  * The objects by pk.
  *
- * @typedef {{[pk: string]: import('../use/objectInstance.js').ExistingCrudObject}} ObjectsByPk
+ * @typedef {{[pk: import('../config/commonCrud.js').Pk]: import('../use/objectInstance.js').ExistingCrudObject}} ObjectsByPk
  */
 /**
  * The objects in order, based on .order & .objects.
@@ -34,7 +34,7 @@
 /**
  * The order of the objects in the list.
  *
- * @typedef {import('vue').ComputedRef<string[]>} ListOrder
+ * @typedef {import('vue').ComputedRef<import('../config/commonCrud.js').Pk[]>} ListOrder
  */
 /**
  * @typedef {object} ListInstanceRawStateCrud
@@ -45,7 +45,7 @@
  * @property {import('../config/listCrud.js').CrudExecuteActionFn} executeAction - The execute action function.
  */
 /**
- * @typedef {Map<string, import('vue').Reactive<import('../use/objectInstance.js').ExistingCrudObject>>} ObjectsMap
+ * @typedef {Map<import('../config/commonCrud.js').Pk, import('vue').Reactive<import('../use/objectInstance.js').ExistingCrudObject>>} ObjectsMap
  */
 /**
  * @typedef {object} PaginateInfo
@@ -106,13 +106,13 @@
  * @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 {(objectId: import('../config/commonCrud.js').PkInput) => void} deleteListObject - Deletes an object from the list by pk.
  * @property {(options?: ClearListOptions) => void} clearList - Clears the list objects and optionally keeps pagination, totals,
  *  or error state.
- * @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 {(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 {() => import('../config/commonCrud.js').Pk} getFakePk - Generates a unique fake pk for use within the list.
+ * @property {(args?: import('../config/listCrud.js').AdditionalListArgs) => 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 {(args?: {pks?: import('../config/commonCrud.js').Pk[]} & import('../config/listCrud.js').AdditionalListArgs) => Promise<boolean>} bulkDelete - Deletes objects from the list by pk, returning a promise to a boolean indicating success.
+ * @property {(args: {action: string, pks?: import('../config/commonCrud.js').Pk[]} & import('../config/listCrud.js').AdditionalListArgs) => Promise<object|string|boolean|null>} executeAction - Initiates an action on all objects in the list, returning the response, or null 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.
  */
@@ -251,7 +251,7 @@ export type ListInstanceOptions = {
  * The objects by pk.
  */
 export type ObjectsByPk = {
-    [pk: string]: import("../use/objectInstance.js").ExistingCrudObject;
+    [pk: import("../config/commonCrud.js").Pk]: import("../use/objectInstance.js").ExistingCrudObject;
 };
 /**
  * The objects in order, based on .order & .objects.
@@ -260,7 +260,7 @@ export type ObjectsInOrder = import("vue").ComputedRef<import("../use/objectInst
 /**
  * The order of the objects in the list.
  */
-export type ListOrder = import("vue").ComputedRef<string[]>;
+export type ListOrder = import("vue").ComputedRef<import("../config/commonCrud.js").Pk[]>;
 export type ListInstanceRawStateCrud = {
     /**
      * - The arguments to be passed to the crud handlers.
@@ -283,7 +283,7 @@ export type ListInstanceRawStateCrud = {
      */
     executeAction: import("../config/listCrud.js").CrudExecuteActionFn;
 };
-export type ObjectsMap = Map<string, import("vue").Reactive<import("../use/objectInstance.js").ExistingCrudObject>>;
+export type ObjectsMap = Map<import("../config/commonCrud.js").Pk, import("vue").Reactive<import("../use/objectInstance.js").ExistingCrudObject>>;
 export type PaginateInfo = {
     /**
      * - The total records.
@@ -391,7 +391,7 @@ export type ListInstanceMyFunctions = {
     /**
      * - Deletes an object from the list by pk.
      */
-    deleteListObject: (objectId: string) => void;
+    deleteListObject: (objectId: import("../config/commonCrud.js").PkInput) => void;
     /**
      * - Clears the list objects and optionally keeps pagination, totals,
      * or error state.
@@ -400,21 +400,24 @@ export type ListInstanceMyFunctions = {
     /**
      * - Generates a unique fake pk for use within the list.
      */
-    getFakePk: () => string;
+    getFakePk: () => import("../config/commonCrud.js").Pk;
     /**
      * - Initiates a fetch to retrieve objects according to the CRUD configuration, returning a promise to a boolean indicating success.
      */
-    list: () => import("../utils/cancellablePromise.js").MaybeCancellablePromise<boolean | never>;
+    list: (args?: import("../config/listCrud.js").AdditionalListArgs) => import("../utils/cancellablePromise.js").MaybeCancellablePromise<boolean | never>;
     /**
      * - Deletes objects from the list by pk, returning a promise to a boolean indicating success.
      */
-    bulkDelete: (args: {
-        pks?: string[];
-    }) => Promise<boolean>;
+    bulkDelete: (args?: {
+        pks?: import("../config/commonCrud.js").Pk[];
+    } & import("../config/listCrud.js").AdditionalListArgs) => Promise<boolean>;
     /**
-     * - Initiates an action on all objects in the list, returning the response, or false if the action failed.
+     * - Initiates an action on all objects in the list, returning the response, or null if the action failed.
      */
-    executeAction: () => Promise<object | string | false>;
+    executeAction: (args: {
+        action: string;
+        pks?: import("../config/commonCrud.js").Pk[];
+    } & import("../config/listCrud.js").AdditionalListArgs) => Promise<object | string | boolean | null>;
     /**
      * - The method to update pagination information.
      */

package/types/use/listRelated.d.ts

@@ -26,18 +26,18 @@
  *
  * @typedef {object} ListRelatedRawState
  * @property {{
- *     [pk: string]: {
+ *     [pk: import('../config/commonCrud.js').Pk]: {
  *         [rule: string]: import('vue').ComputedRef<any>,
  *     },
  * }} relatedObjects - Stores computed references to related objects, allowing for dynamic access based on object pk and specific rules.
  * @property {ListRelatedRules} relatedObjectsRules - Defines the rules for establishing relationships, such as foreign key links and sorting orders.
  * @property {{
- *     [pk: string]: {
+ *     [pk: import('../config/commonCrud.js').Pk]: {
  *         [rule: string]: import('vue').ComputedRef<[object, string]>,
  *     },
  * }} objAndKeyForPkAndRule - Maps each object pk and rule to a tuple consisting of the related object and its respective key, facilitating direct data manipulation.
  * @property {{
- *     [pk: string]: {
+ *     [pk: import('../config/commonCrud.js').Pk]: {
  *         [rule: string]: import('vue').ComputedRef<any>,
  *     },
  * }} fkForPkAndRule - Maintains computed references to the foreign keys for each object pk and rule, crucial for navigating complex data relationships.
@@ -210,7 +210,7 @@ export type ListRelatedRawState = {
      * - Stores computed references to related objects, allowing for dynamic access based on object pk and specific rules.
      */
     relatedObjects: {
-        [pk: string]: {
+        [pk: import("../config/commonCrud.js").Pk]: {
             [rule: string]: import("vue").ComputedRef<any>;
         };
     };
@@ -222,7 +222,7 @@ export type ListRelatedRawState = {
      * - Maps each object pk and rule to a tuple consisting of the related object and its respective key, facilitating direct data manipulation.
      */
     objAndKeyForPkAndRule: {
-        [pk: string]: {
+        [pk: import("../config/commonCrud.js").Pk]: {
             [rule: string]: import("vue").ComputedRef<[object, string]>;
         };
     };
@@ -230,7 +230,7 @@ export type ListRelatedRawState = {
      * - Maintains computed references to the foreign keys for each object pk and rule, crucial for navigating complex data relationships.
      */
     fkForPkAndRule: {
-        [pk: string]: {
+        [pk: import("../config/commonCrud.js").Pk]: {
             [rule: string]: import("vue").ComputedRef<any>;
         };
     };

package/types/use/listSubscription.d.ts

@@ -47,12 +47,15 @@
  *
  * @typedef {ListSubscriptionFunctions & ListSubscriptionProperties} ListSubscription
  */
+/**
+ * @typedef {object} ListSubscriptionOwnOptions
+ * @property {import("./listInstance.js").ListInstance} [listInstance] - A list instance to use instead of creating one.
+ */
 /**
  * Defines the settings required to establish a list subscription, detailing how list instances should handle updates
  *  and subscriptions based on the given properties.
  *
- * @typedef {object & import("./listInstance.js").ListInstanceOptions} ListSubscriptionOptions
- * @property {import("./listInstance.js").ListInstance} listInstance - A list instance to use instead of creating one.
+ * @typedef {import("./listInstance.js").ListInstanceOptions & ListSubscriptionOwnOptions} ListSubscriptionOptions
  */
 /**
  * A Vue composition function that creates multiple list subscriptions, and returns them as an object.
@@ -191,8 +194,14 @@ export type ListSubscriptionProperties = {
  * An instance of a list subscription, returned by `useListSubscription`.
  */
 export type ListSubscription = ListSubscriptionFunctions & ListSubscriptionProperties;
+export type ListSubscriptionOwnOptions = {
+    /**
+     * - A list instance to use instead of creating one.
+     */
+    listInstance?: import("./listInstance.js").ListInstance;
+};
 /**
  * Defines the settings required to establish a list subscription, detailing how list instances should handle updates
  *  and subscriptions based on the given properties.
  */
-export type ListSubscriptionOptions = object & import("./listInstance.js").ListInstanceOptions;
+export type ListSubscriptionOptions = import("./listInstance.js").ListInstanceOptions & ListSubscriptionOwnOptions;

package/types/use/loading.d.ts

@@ -3,13 +3,19 @@
  * @typedef {Readonly<LoadingRef>} LoadingReadonlyRef
  */
 /**
- * The loading state API.
- *
- * @typedef {object} LoadingStatus
+ * @typedef {object} LoadingProperties
  * @property {LoadingReadonlyRef} loading - Whether the component is loading.
+ */
+/**
+ * @typedef {object} LoadingFunctions
  * @property {() => void} setLoading - Set the loading state to true.
  * @property {() => void} clearLoading - Set the loading state to false.
  */
+/**
+ * The loading state API.
+ *
+ * @typedef {LoadingProperties & LoadingFunctions} LoadingStatus
+ */
 /**
  * A composable function for managing loading state.
  *
@@ -18,14 +24,13 @@
 export function useLoading(): LoadingStatus;
 export type LoadingRef = import("vue").Ref<boolean | undefined>;
 export type LoadingReadonlyRef = Readonly<LoadingRef>;
-/**
- * The loading state API.
- */
-export type LoadingStatus = {
+export type LoadingProperties = {
     /**
      * - Whether the component is loading.
      */
     loading: LoadingReadonlyRef;
+};
+export type LoadingFunctions = {
     /**
      * - Set the loading state to true.
      */
@@ -35,3 +40,7 @@ export type LoadingStatus = {
      */
     clearLoading: () => void;
 };
+/**
+ * The loading state API.
+ */
+export type LoadingStatus = LoadingProperties & LoadingFunctions;

package/types/use/loadingError.d.ts

@@ -1,5 +1,7 @@
 /**
- * @typedef {import('./loading.js').LoadingStatus & import('./error.js').ErrorStatus} LoadingErrorStatus
+ * @typedef {import('./loading.js').LoadingProperties & import('./error.js').ErrorProperties} LoadingErrorProperties
+ * @typedef {import('./loading.js').LoadingFunctions & import('./error.js').ErrorFunctions} LoadingErrorFunctions
+ * @typedef {LoadingErrorProperties & LoadingErrorFunctions} LoadingErrorStatus
  */
 /**
  * A composable function combining loading and error state management.
@@ -7,4 +9,6 @@
  * @returns {LoadingErrorStatus} - An object containing reactive fields and actions for both loading and error state.
  */
 export function useLoadingError(): LoadingErrorStatus;
-export type LoadingErrorStatus = import("./loading.js").LoadingStatus & import("./error.js").ErrorStatus;
+export type LoadingErrorProperties = import("./loading.js").LoadingProperties & import("./error.js").ErrorProperties;
+export type LoadingErrorFunctions = import("./loading.js").LoadingFunctions & import("./error.js").ErrorFunctions;
+export type LoadingErrorStatus = LoadingErrorProperties & LoadingErrorFunctions;

package/types/use/objectInstance.d.ts

@@ -59,11 +59,11 @@ export function useObjectInstances(instanceArgs: {
  * ```
  *
  * @param {ObjectInstanceOptions} options - The options to be passed to useObjectInstance.
- * @returns {ObjectInstance} - An object used to manage create, retrieve, update, delete, and patch operations.
+ * @returns {ObjectInstance} - An object used to manage create, retrieve, update, delete, patch, and executeAction operations.
  */
 export function useObjectInstance({ props, handlers }: ObjectInstanceOptions): ObjectInstance;
 /**
- * A composition function to manage create, retrieve, update, delete, and patch operations.
+ * A composition function to manage create, retrieve, update, delete, patch, and executeAction operations.
  *
  * @module use/objectInstance.js
  */
@@ -92,7 +92,7 @@ export function useObjectInstance({ props, handlers }: ObjectInstanceOptions): O
  * Reactive arguments to be passed to the object instance.
  *
  * @typedef {object} ObjectInstanceRawProps
- * @property {string} [pk] - The pk of the object, optional to support creating new objects.
+ * @property {import('../config/commonCrud.js').PkInput} [pk] - The pk of the object, optional to support creating new objects.
  * @property {string} pkKey - The pk key of the object.
  * @property {object} params - The arguments to be passed to the retrieve function.
  * @property {import('../config/objectCrud.js').ObjectTarget} target - The arguments to be passed to the crud handlers.
@@ -106,13 +106,14 @@ export function useObjectInstance({ props, handlers }: ObjectInstanceOptions): O
  * @property {import('../config/objectCrud.js').CrudPatchFn} patch - The patch function.
  * @property {import('../config/objectCrud.js').CrudDeleteFn} delete - The delete function.
  * @property {import('../config/objectCrud.js').CrudObjectSubscribeFn} subscribe - The subscribe function.
+ * @property {import('../config/objectCrud.js').CrudObjectExecuteActionFn} executeAction - The executeAction function.
  */
 /**
  * The raw state of the object instance.
  *
  * @typedef {object} ObjectInstanceRawMyState
  * @property {import('vue').Reactive<ObjectInstanceRawStateCrud>} crud - The crud handlers.
- * @property {import('vue').Ref<string|undefined>} pk - The pk of the object.
+ * @property {import('vue').Ref<import('../config/commonCrud.js').Pk|undefined>} pk - The pk of the object.
  * @property {import('vue').Ref<string|undefined>} pkKey - The pk key of the object.
  * @property {import('vue').Ref<{[key:string]: any}>} params - The arguments to be passed to the retrieve function.
  * @property {import('vue').Reactive<CrudObject>} object - The object.
@@ -121,7 +122,7 @@ export function useObjectInstance({ props, handlers }: ObjectInstanceOptions): O
 /**
  * The raw state of the object instance.
  *
- * @typedef {ObjectInstanceRawMyState & Pick<import('./loadingError.js').LoadingErrorStatus, "loading" | "error" | "errored">} ObjectInstanceRawState
+ * @typedef {ObjectInstanceRawMyState & import('./loadingError.js').LoadingErrorProperties} ObjectInstanceRawState
  */
 /**
  * Manages a reactive state of an object including its CRUD status, loading states, and any operational errors.
@@ -132,22 +133,26 @@ export function useObjectInstance({ props, handlers }: ObjectInstanceOptions): O
 /** @typedef {{ object: NewCrudObject }} ObjectInstanceCreateArgs */
 /** @typedef {{ object: ExistingCrudObject }} ObjectInstanceUpdateArgs */
 /** @typedef {{ partialObject: ExistingCrudObject }} ObjectInstancePatchArgs */
+/**
+ * @typedef {{[key:string]: any}} AdditionalArgs
+ */
 /**
  * The functions available on the object instance.
  *
  * @typedef {object} ObjectInstanceMyFunctions
- * @property {(args: ObjectInstanceCreateArgs) => import('../utils/cancellablePromise.js').MaybeCancellablePromise<boolean|never>} create - Called to turn the current object into a new object on the server.
- * @property {(args?: import('./cancellableIntent.js').CommonRunTracking) => import('../utils/cancellablePromise.js').MaybeCancellablePromise<boolean|never>} retrieve - Called to retrieve the current object by pk from the server.
- * @property {(args: ObjectInstanceUpdateArgs) => import('../utils/cancellablePromise.js').MaybeCancellablePromise<boolean|never>} update - Called to update the current object on the server.
- * @property {() => import('../utils/cancellablePromise.js').MaybeCancellablePromise<boolean|never>} delete - Called to delete the current object on the server.
- * @property {(args: ObjectInstancePatchArgs) => import('../utils/cancellablePromise.js').MaybeCancellablePromise<boolean|never>} patch - Called to patch the current object on the server.
+ * @property {(args: ObjectInstanceCreateArgs & AdditionalArgs) => import('../utils/cancellablePromise.js').MaybeCancellablePromise<boolean|never>} create - Called to turn the current object into a new object on the server.
+ * @property {(args?: Partial<import('./cancellableIntent.js').CommonRunTracking> & AdditionalArgs) => import('../utils/cancellablePromise.js').MaybeCancellablePromise<boolean|never>} retrieve - Called to retrieve the current object by pk from the server.
+ * @property {(args: ObjectInstanceUpdateArgs & AdditionalArgs) => import('../utils/cancellablePromise.js').MaybeCancellablePromise<boolean|never>} update - Called to update the current object on the server.
+ * @property {(args?: AdditionalArgs) => import('../utils/cancellablePromise.js').MaybeCancellablePromise<boolean|never>} delete - Called to delete the current object on the server.
+ * @property {(args: ObjectInstancePatchArgs & AdditionalArgs) => import('../utils/cancellablePromise.js').MaybeCancellablePromise<boolean|never>} patch - Called to patch the current object on the server.
+ * @property {(args: {action: string} & AdditionalArgs) => import('../utils/cancellablePromise.js').MaybeCancellablePromise<boolean|never>} executeAction - Called to execute certain action on the current object.
  * @property {() => void} clear - Called to clear the object state.
  */
 /**
  * The functions available on the object instance, including the ability to clear LoadingError errors.
  *
  * @typedef {(
- *     Pick<import('./loadingError.js').LoadingErrorStatus, "clearError"> &
+ *     import('./error.js').ErrorReadOnlyFunctions &
  *     ObjectInstanceMyFunctions
  * )} ObjectInstanceFunctions
  */
@@ -212,7 +217,7 @@ export type ObjectInstanceRawProps = {
     /**
      * - The pk of the object, optional to support creating new objects.
      */
-    pk?: string;
+    pk?: import("../config/commonCrud.js").PkInput;
     /**
      * - The pk key of the object.
      */
@@ -255,6 +260,10 @@ export type ObjectInstanceRawStateCrud = {
      * - The subscribe function.
      */
     subscribe: import("../config/objectCrud.js").CrudObjectSubscribeFn;
+    /**
+     * - The executeAction function.
+     */
+    executeAction: import("../config/objectCrud.js").CrudObjectExecuteActionFn;
 };
 /**
  * The raw state of the object instance.
@@ -267,7 +276,7 @@ export type ObjectInstanceRawMyState = {
     /**
      * - The pk of the object.
      */
-    pk: import("vue").Ref<string | undefined>;
+    pk: import("vue").Ref<import("../config/commonCrud.js").Pk | undefined>;
     /**
      * - The pk key of the object.
      */
@@ -290,7 +299,7 @@ export type ObjectInstanceRawMyState = {
 /**
  * The raw state of the object instance.
  */
-export type ObjectInstanceRawState = ObjectInstanceRawMyState & Pick<import("./loadingError.js").LoadingErrorStatus, "loading" | "error" | "errored">;
+export type ObjectInstanceRawState = ObjectInstanceRawMyState & import("./loadingError.js").LoadingErrorProperties;
 /**
  * Manages a reactive state of an object including its CRUD status, loading states, and any operational errors.
  * Reactivity ensures that any changes in state immediately reflect in the UI components that depend on this state.
@@ -305,6 +314,9 @@ export type ObjectInstanceUpdateArgs = {
 export type ObjectInstancePatchArgs = {
     partialObject: ExistingCrudObject;
 };
+export type AdditionalArgs = {
+    [key: string]: any;
+};
 /**
  * The functions available on the object instance.
  */
@@ -312,23 +324,29 @@ export type ObjectInstanceMyFunctions = {
     /**
      * - Called to turn the current object into a new object on the server.
      */
-    create: (args: ObjectInstanceCreateArgs) => import("../utils/cancellablePromise.js").MaybeCancellablePromise<boolean | never>;
+    create: (args: ObjectInstanceCreateArgs & AdditionalArgs) => import("../utils/cancellablePromise.js").MaybeCancellablePromise<boolean | never>;
     /**
      * - Called to retrieve the current object by pk from the server.
      */
-    retrieve: (args?: import("./cancellableIntent.js").CommonRunTracking) => import("../utils/cancellablePromise.js").MaybeCancellablePromise<boolean | never>;
+    retrieve: (args?: Partial<import("./cancellableIntent.js").CommonRunTracking> & AdditionalArgs) => import("../utils/cancellablePromise.js").MaybeCancellablePromise<boolean | never>;
     /**
      * - Called to update the current object on the server.
      */
-    update: (args: ObjectInstanceUpdateArgs) => import("../utils/cancellablePromise.js").MaybeCancellablePromise<boolean | never>;
+    update: (args: ObjectInstanceUpdateArgs & AdditionalArgs) => import("../utils/cancellablePromise.js").MaybeCancellablePromise<boolean | never>;
     /**
      * - Called to delete the current object on the server.
      */
-    delete: () => import("../utils/cancellablePromise.js").MaybeCancellablePromise<boolean | never>;
+    delete: (args?: AdditionalArgs) => import("../utils/cancellablePromise.js").MaybeCancellablePromise<boolean | never>;
     /**
      * - Called to patch the current object on the server.
      */
-    patch: (args: ObjectInstancePatchArgs) => import("../utils/cancellablePromise.js").MaybeCancellablePromise<boolean | never>;
+    patch: (args: ObjectInstancePatchArgs & AdditionalArgs) => import("../utils/cancellablePromise.js").MaybeCancellablePromise<boolean | never>;
+    /**
+     * - Called to execute certain action on the current object.
+     */
+    executeAction: (args: {
+        action: string;
+    } & AdditionalArgs) => import("../utils/cancellablePromise.js").MaybeCancellablePromise<boolean | never>;
     /**
      * - Called to clear the object state.
      */
@@ -337,7 +355,7 @@ export type ObjectInstanceMyFunctions = {
 /**
  * The functions available on the object instance, including the ability to clear LoadingError errors.
  */
-export type ObjectInstanceFunctions = (Pick<import("./loadingError.js").LoadingErrorStatus, "clearError"> & ObjectInstanceMyFunctions);
+export type ObjectInstanceFunctions = (import("./error.js").ErrorReadOnlyFunctions & ObjectInstanceMyFunctions);
 /**
  * The properties of the object instance.
  */

package/types/use/objectSubscription.d.ts

@@ -43,14 +43,17 @@
  * @property {boolean|undefined} intendToSubscribe - Whether the object intends to subscribe.
  */
 /**
- * Options for initializing an object subscription, including reactive props and non-reactive handlers.
- *
- * @typedef {object & import('./objectInstance.js').ObjectInstanceOptions} ObjectSubscriptionOptions
+ * @typedef {object} ObjectSubscriptionOwnOptions
  * @property {import('./objectInstance.js').ObjectInstance} [objectInstance] - An object instance to use instead of creating a new one.
  * @property {import('vue').UnwrapNestedRefs<(
  *     ObjectSubscriptionRawProps & import('./objectInstance.js').ObjectInstanceRawProps
  * )>} props - The reactive args to be passed to useObjectInstance.
- * @property {import('./objectInstance.js').ObjectInstanceHandlers} [handlers] - The handlers to be passed to useObjectInstance.
+ * @property {import('../config/objectCrud.js').ObjectCrudHandlers} [handlers] - The handlers to be passed to useObjectInstance.
+ */
+/**
+ * Options for initializing an object subscription, including reactive props and non-reactive handlers.
+ *
+ * @typedef {ObjectSubscriptionOwnOptions & import('./objectInstance.js').ObjectInstanceOptions} ObjectSubscriptionOptions
  */
 /**
  * Initializes multiple object subscriptions based on provided arguments.
@@ -208,10 +211,24 @@ export type ObjectSubscriptionRawProps = {
      */
     intendToSubscribe: boolean | undefined;
 };
+export type ObjectSubscriptionOwnOptions = {
+    /**
+     * - An object instance to use instead of creating a new one.
+     */
+    objectInstance?: import("./objectInstance.js").ObjectInstance;
+    /**
+     * - The reactive args to be passed to useObjectInstance.
+     */
+    props: import("vue").UnwrapNestedRefs<(ObjectSubscriptionRawProps & import("./objectInstance.js").ObjectInstanceRawProps)>;
+    /**
+     * - The handlers to be passed to useObjectInstance.
+     */
+    handlers?: import("../config/objectCrud.js").ObjectCrudHandlers;
+};
 /**
  * Options for initializing an object subscription, including reactive props and non-reactive handlers.
  */
-export type ObjectSubscriptionOptions = object & import("./objectInstance.js").ObjectInstanceOptions;
+export type ObjectSubscriptionOptions = ObjectSubscriptionOwnOptions & import("./objectInstance.js").ObjectInstanceOptions;
 /**
  * The context bound to shared objectSubscription functions.
  */

package/types/use/proxyError.d.ts

@@ -1,27 +1,30 @@
 /**
- * @typedef {Pick<import('./error.js').ErrorStatus, "error" | "errored" | "clearError">} ReadonlyErrorStatus
+ * @typedef {import('./error.js').ReadonlyErrorStatus | import("vue").Reactive<import('./error.js').ReadonlyErrorStatus>} WatchableError
+ * @typedef {import('vue').MaybeRef<WatchableError>} MaybeRefWatchableError
  */
 /**
- * @typedef {import("vue").Ref<ReadonlyErrorStatus>} RefErrorStatus
- */
-/**
- * @typedef {ReadonlyErrorStatus | RefErrorStatus} WatchableError
- */
-/**
- * @typedef {import('vue').Ref<WatchableError[]>} WatchableErrorRef
+ * A composable function for aggregating error state across multiple sources.
+ *
+ * @param {import('vue').MaybeRef<MaybeRefWatchableError[]>} errors - The error states to monitor.
+ * @returns {import('./error.js').ReadonlyErrorStatus} An object containing aggregated reactive fields and actions for error state.
  */
+export function useProxyError(errors: import("vue").MaybeRef<MaybeRefWatchableError[]>): import("./error.js").ReadonlyErrorStatus;
 /**
- * @typedef {WatchableErrorRef|WatchableError[]} WatchableErrors
+ * @typedef {{ state: import('vue').Reactive<import('./error.js').ErrorProperties> } & import('./error.js').ErrorReadOnlyFunctions} SeparateStateError
  */
 /**
- * A composable function for aggregating error state across multiple sources.
+ * Adapt an object with reactive error state into a WatchableError shape.
+ * Accepts either an object with a `state` property or an object that already exposes error/errored/clearError.
  *
- * @param {WatchableErrors} errors - The error states to monitor.
- * @returns {ReadonlyErrorStatus} An object containing aggregated reactive fields and actions for error state.
+ * @param {import('vue').MaybeRef<
+ *     SeparateStateError |
+ *     WatchableError
+ * >} source - The source object to adapt.
+ * @returns {WatchableError} - The adapted WatchableError object.
  */
-export function useProxyError(errors: WatchableErrors): ReadonlyErrorStatus;
-export type ReadonlyErrorStatus = Pick<import("./error.js").ErrorStatus, "error" | "errored" | "clearError">;
-export type RefErrorStatus = import("vue").Ref<ReadonlyErrorStatus>;
-export type WatchableError = ReadonlyErrorStatus | RefErrorStatus;
-export type WatchableErrorRef = import("vue").Ref<WatchableError[]>;
-export type WatchableErrors = WatchableErrorRef | WatchableError[];
+export function asWatchableError(source: import("vue").MaybeRef<SeparateStateError | WatchableError>): WatchableError;
+export type WatchableError = import("./error.js").ReadonlyErrorStatus | import("vue").Reactive<import("./error.js").ReadonlyErrorStatus>;
+export type MaybeRefWatchableError = import("vue").MaybeRef<WatchableError>;
+export type SeparateStateError = {
+    state: import("vue").Reactive<import("./error.js").ErrorProperties>;
+} & import("./error.js").ErrorReadOnlyFunctions;