react-hooks-global-states 4.0.7 → 5.0.1

package/lib/src/GlobalStore.context.d.ts

@@ -1,187 +1,50 @@
-import { ActionCollectionConfig, StateHook, StateSetter, ActionCollectionResult, StateGetter, StateChanges, BaseMetadata, MetadataSetter } from './GlobalStore.types';
+import { ActionCollectionConfig, StateHook, StateSetter, ActionCollectionResult, StateGetter, BaseMetadata, MetadataSetter, GlobalStoreCallbacks } from './GlobalStore.types';
 import React, { PropsWithChildren } from 'react';
-export type ProviderAPI<Value, Metadata> = {
+export type ContextProviderAPI<Value, Metadata extends BaseMetadata | unknown> = {
     setMetadata: MetadataSetter<Metadata>;
     setState: StateSetter<Value>;
     getState: StateGetter<Value>;
     getMetadata: () => Metadata;
     actions: Record<string, (...args: any[]) => void>;
 };
-type Provider<Value, Metadata extends BaseMetadata = BaseMetadata> = React.FC<PropsWithChildren<{
+export type ContextProvider<Value, Metadata extends BaseMetadata | unknown> = React.FC<PropsWithChildren<{
     value?: Value | ((initialValue: Value) => Value);
-    ref?: React.MutableRefObject<ProviderAPI<Value, Metadata>>;
+    ref?: React.RefObject<ContextProviderAPI<Value, Metadata>>;
 }>>;
-type Context<Value, PublicStateMutator, Metadata extends BaseMetadata> = (() => StateHook<Value, PublicStateMutator, Metadata>) & {
-    /**
-     * Allows you to create a selector hooks
-     * This hooks only works when contained in the scope of the provider
-     */
-    createSelectorHook: <RootState, RootSelectorResult, RootDerivate = RootSelectorResult extends never ? RootState : RootSelectorResult>(this: Context<RootState, PublicStateMutator, Metadata>, mainSelector?: (state: Value) => RootSelectorResult, args?: {
+export type ContextHook<Value, PublicStateMutator, Metadata extends BaseMetadata | unknown> = (() => StateHook<Value, PublicStateMutator, Metadata>) & {
+    createSelectorHook: <RootState, RootSelectorResult, RootDerivate = RootSelectorResult extends never ? RootState : RootSelectorResult>(this: ContextHook<RootState, PublicStateMutator, Metadata>, mainSelector?: (state: Value) => RootSelectorResult, args?: {
         isEqual?: (current: RootDerivate, next: RootDerivate) => boolean;
         isEqualRoot?: (current: RootState, next: RootState) => boolean;
         name?: string;
     }) => StateHook<RootDerivate, PublicStateMutator, Metadata>;
 };
 export interface CreateContext {
-    createContext<Value>(state: Value): readonly [
-        Context<Value, StateSetter<Value>, BaseMetadata>,
-        Provider<Context<Value, StateSetter<Value>, BaseMetadata>>
-    ];
-    createContext<Value, Metadata extends BaseMetadata, ActionsConfig extends ActionCollectionConfig<Value, Metadata> | {} | null = null, StoreAPI = {
-        setMetadata: MetadataSetter<Metadata>;
-        setState: StateSetter<Value>;
-        getState: StateGetter<Value>;
-        getMetadata: () => Metadata;
-        actions: ActionsConfig extends null ? null : Record<string, (...args: any[]) => void>;
-    }>(state: Value, config: Readonly<{
-        /**
-         * @deprecated We needed to move the actions parameter as a third argument to fix several issues with the type inference of the actions
-         */
-        actions?: ActionsConfig;
-        /**
-         * Non reactive information about the state
-         */
-        metadata?: Metadata;
-        /**
-         * executes immediately after the store is created
-         * */
-        onInit?: (args: StoreAPI) => void;
-        onStateChanged?: (args: StoreAPI & StateChanges<Value>) => void;
-        onSubscribed?: (args: StoreAPI) => void;
-        /**
-         * callback function called every time the state is about to change and it allows you to prevent the state change
-         */
-        computePreventStateChange?: (args: StoreAPI & StateChanges<Value>) => boolean;
-        onUnMount?: () => void;
-    }>): readonly [
-        Context<Value, ActionsConfig extends null ? StateSetter<Value> : ActionCollectionResult<Value, Metadata, ActionsConfig>, Metadata>,
-        Provider<Context<Value, ActionsConfig extends null ? StateSetter<Value> : ActionCollectionResult<Value, Metadata, ActionsConfig>, Metadata>, Metadata>
-    ];
-    createContext<Value, Metadata extends BaseMetadata, ActionsConfig extends ActionCollectionConfig<Value, Metadata>, StoreAPI = {
-        setMetadata: MetadataSetter<Metadata>;
-        setState: StateSetter<Value>;
-        getState: StateGetter<Value>;
-        getMetadata: () => Metadata;
-        actions: Record<string, (...args: any[]) => void>;
-    }>(state: Value, config: Readonly<{
-        /**
-         * Non reactive information about the state
-         */
-        metadata?: Metadata;
-        /**
-         * executes immediately after the store is created
-         * */
-        onInit?: (args: StoreAPI) => void;
-        onStateChanged?: (args: StoreAPI & StateChanges<Value>) => void;
-        onSubscribed?: (args: StoreAPI) => void;
-        /**
-         * callback function called every time the state is about to change and it allows you to prevent the state change
-         */
-        computePreventStateChange?: (args: StoreAPI & StateChanges<Value>) => boolean;
-        onUnMount?: () => void;
-    }>, actions: ActionsConfig): readonly [
-        Context<Value, ActionCollectionResult<Value, Metadata, ActionsConfig>, Metadata>,
-        Provider<Context<Value, ActionCollectionResult<Value, Metadata, ActionsConfig>, Metadata>>
-    ];
-    createContext<Value, Metadata extends BaseMetadata, ActionsConfig extends ActionCollectionConfig<Value, Metadata>, StoreAPI = {
-        setMetadata: MetadataSetter<Metadata>;
-        setState: StateSetter<Value>;
-        getState: StateGetter<Value>;
-        getMetadata: () => Metadata;
-    }>(state: Value, builder: () => ActionsConfig, config?: Readonly<{
-        /**
-         * Non reactive information about the state
-         */
-        metadata?: Metadata;
-        /**
-         * executes immediately after the store is created
-         * */
-        onInit?: (args: StoreAPI) => void;
-        onStateChanged?: (args: StoreAPI & StateChanges<Value>) => void;
-        onSubscribed?: (args: StoreAPI) => void;
-        /**
-         * callback function called every time the state is about to change and it allows you to prevent the state change
-         */
-        computePreventStateChange?: (args: StoreAPI & StateChanges<Value>) => boolean;
-        onUnMount?: () => void;
-    }>): readonly [
-        Context<Value, ActionCollectionResult<Value, Metadata, ActionsConfig>, Metadata>,
-        Provider<Context<Value, ActionCollectionResult<Value, Metadata, ActionsConfig>, Metadata>>
+    <Value, Hook = ContextHook<Value, StateSetter<Value>, BaseMetadata>>(builder: () => Value): readonly [
+        Hook,
+        ContextProvider<Hook, BaseMetadata>
     ];
+    <Value, Metadata extends BaseMetadata | unknown, Hook = ContextHook<Value, StateSetter<Value>, Metadata>>(builder: () => Value, args: {
+        name?: string;
+        metadata?: unknown;
+        callbacks?: GlobalStoreCallbacks<Value, Metadata> & {
+            onUnMount?: () => void;
+        };
+    }): readonly [Hook, ContextProvider<Hook, Metadata>];
+    <Value, Metadata extends BaseMetadata | unknown, ActionsConfig extends ActionCollectionConfig<Value, Metadata>, PublicStateMutator = keyof ActionsConfig extends never | undefined ? StateSetter<Value> : ActionCollectionResult<Value, Metadata, NonNullable<ActionsConfig>>, Hook = ContextHook<Value, PublicStateMutator, Metadata>>(builder: () => Value, args: {
+        name?: string;
+        metadata?: unknown;
+        callbacks?: GlobalStoreCallbacks<Value, Metadata> & {
+            onUnMount?: () => void;
+        };
+        actions?: ActionCollectionConfig<Value, Metadata>;
+    }): readonly [Hook, ContextProvider<Hook, Metadata>];
+    <Value, Metadata extends BaseMetadata | unknown, ActionsConfig extends ActionCollectionConfig<Value, Metadata>, Hook = ContextHook<Value, ActionCollectionResult<Value, Metadata, ActionsConfig>, Metadata>>(builder: () => Value, args: {
+        name?: string;
+        metadata?: unknown;
+        callbacks?: GlobalStoreCallbacks<Value, Metadata> & {
+            onUnMount?: () => void;
+        };
+        actions: ActionCollectionConfig<Value, Metadata>;
+    }): readonly [Hook, ContextProvider<Hook, Metadata>];
 }
-export declare const createContext: {
-    <Value>(state: Value): readonly [Context<Value, StateSetter<Value>, BaseMetadata>, Provider<Context<Value, StateSetter<Value>, BaseMetadata>, BaseMetadata>];
-    <Value_1, Metadata extends BaseMetadata, ActionsConfig extends {} | ActionCollectionConfig<Value_1, Metadata> = null, StoreAPI = {
-        setMetadata: MetadataSetter<Metadata>;
-        setState: StateSetter<Value_1>;
-        getState: StateGetter<Value_1>;
-        getMetadata: () => Metadata;
-        actions: ActionsConfig extends null ? null : Record<string, (...args: any[]) => void>;
-    }>(state: Value_1, config: Readonly<{
-        /**
-         * @deprecated We needed to move the actions parameter as a third argument to fix several issues with the type inference of the actions
-         */
-        actions?: ActionsConfig;
-        /**
-         * Non reactive information about the state
-         */
-        metadata?: Metadata;
-        /**
-         * executes immediately after the store is created
-         * */
-        onInit?: (args: StoreAPI) => void;
-        onStateChanged?: (args: StoreAPI & StateChanges<Value_1>) => void;
-        onSubscribed?: (args: StoreAPI) => void;
-        /**
-         * callback function called every time the state is about to change and it allows you to prevent the state change
-         */
-        computePreventStateChange?: (args: StoreAPI & StateChanges<Value_1>) => boolean;
-        onUnMount?: () => void;
-    }>): readonly [Context<Value_1, ActionsConfig extends null ? StateSetter<Value_1> : ActionCollectionResult<Value_1, Metadata, ActionsConfig>, Metadata>, Provider<Context<Value_1, ActionsConfig extends null ? StateSetter<Value_1> : ActionCollectionResult<Value_1, Metadata, ActionsConfig>, Metadata>, Metadata>];
-    <Value_2, Metadata_1 extends BaseMetadata, ActionsConfig_1 extends ActionCollectionConfig<Value_2, Metadata_1>, StoreAPI_1 = {
-        setMetadata: MetadataSetter<Metadata_1>;
-        setState: StateSetter<Value_2>;
-        getState: StateGetter<Value_2>;
-        getMetadata: () => Metadata_1;
-        actions: Record<string, (...args: any[]) => void>;
-    }>(state: Value_2, config: Readonly<{
-        /**
-         * Non reactive information about the state
-         */
-        metadata?: Metadata_1;
-        /**
-         * executes immediately after the store is created
-         * */
-        onInit?: (args: StoreAPI_1) => void;
-        onStateChanged?: (args: StoreAPI_1 & StateChanges<Value_2>) => void;
-        onSubscribed?: (args: StoreAPI_1) => void;
-        /**
-         * callback function called every time the state is about to change and it allows you to prevent the state change
-         */
-        computePreventStateChange?: (args: StoreAPI_1 & StateChanges<Value_2>) => boolean;
-        onUnMount?: () => void;
-    }>, actions: ActionsConfig_1): readonly [Context<Value_2, ActionCollectionResult<Value_2, Metadata_1, ActionsConfig_1>, Metadata_1>, Provider<Context<Value_2, ActionCollectionResult<Value_2, Metadata_1, ActionsConfig_1>, Metadata_1>, BaseMetadata>];
-    <Value_3, Metadata_2 extends BaseMetadata, ActionsConfig_2 extends ActionCollectionConfig<Value_3, Metadata_2>, StoreAPI_2 = {
-        setMetadata: MetadataSetter<Metadata_2>;
-        setState: StateSetter<Value_3>;
-        getState: StateGetter<Value_3>;
-        getMetadata: () => Metadata_2;
-    }>(state: Value_3, builder: () => ActionsConfig_2, config?: Readonly<{
-        /**
-         * Non reactive information about the state
-         */
-        metadata?: Metadata_2;
-        /**
-         * executes immediately after the store is created
-         * */
-        onInit?: (args: StoreAPI_2) => void;
-        onStateChanged?: (args: StoreAPI_2 & StateChanges<Value_3>) => void;
-        onSubscribed?: (args: StoreAPI_2) => void;
-        /**
-         * callback function called every time the state is about to change and it allows you to prevent the state change
-         */
-        computePreventStateChange?: (args: StoreAPI_2 & StateChanges<Value_3>) => boolean;
-        onUnMount?: () => void;
-    }>): readonly [Context<Value_3, ActionCollectionResult<Value_3, Metadata_2, ActionsConfig_2>, Metadata_2>, Provider<Context<Value_3, ActionCollectionResult<Value_3, Metadata_2, ActionsConfig_2>, Metadata_2>, BaseMetadata>];
-};
-export {};
+export declare const createContext: CreateContext;

package/lib/src/GlobalStore.d.ts

@@ -1,64 +1,47 @@
-import { ActionCollectionConfig, StateSetter, GlobalStoreConfig, ActionCollectionResult, MetadataSetter, StateGetter, SubscribeCallbackConfig, SubscribeCallback, SelectorCallback, SubscriberParameters, SubscriptionCallback, MetadataGetter, StateHook, BaseMetadata, StateChanges } from './GlobalStore.types';
-export declare const throwNoSubscribersWereAdded: () => never;
+import { UniqueSymbol } from './GlobalStore.utils';
+import { ActionCollectionConfig, StateSetter, GlobalStoreCallbacks, ActionCollectionResult, MetadataSetter, UseHookConfig, StateGetter, SelectorCallback, SubscriberParameters, MetadataGetter, StateHook, BaseMetadata, StateChanges, StoreTools, ObservableFragment } from './GlobalStore.types';
 /**
  * The GlobalStore class is the main class of the library and it is used to create a GlobalStore instances
  * */
-export declare class GlobalStore<State, Metadata extends BaseMetadata, ActionsConfig extends ActionCollectionConfig<State, Metadata> | null | {} = null, StoreAPI = {
-    setMetadata: MetadataSetter<Metadata>;
-    setState: StateSetter<State>;
-    getState: StateGetter<State>;
-    getMetadata: () => Metadata;
-    actions: any;
-}, PublicStateMutator = ActionsConfig extends null ? StateSetter<State> : ActionCollectionResult<State, Metadata, ActionsConfig>> {
-    protected actionsConfig: ActionsConfig;
-    /**
-     * list of all the subscribers setState functions
-     * @template {State} TState - The type of the state object
-     * */
+export declare class GlobalStore<State, Metadata extends BaseMetadata | unknown, ActionsConfig extends ActionCollectionConfig<State, Metadata> | undefined | unknown, PublicStateMutator = keyof ActionsConfig extends never | undefined ? StateSetter<State> : ActionCollectionResult<State, Metadata, NonNullable<ActionsConfig>>> {
+    protected _name: string;
+    actionsConfig: ActionsConfig | null;
+    callbacks: GlobalStoreCallbacks<State, Metadata> | null;
+    metadata: Metadata;
+    actions: ActionCollectionResult<State, Metadata, NonNullable<ActionsConfig>> | null;
     subscribers: Map<string, SubscriberParameters>;
-    /**
-     * Actions of the store
-     */
-    actions?: ActionsConfig extends null ? null : ActionCollectionResult<State, Metadata, ActionsConfig>;
-    protected config: GlobalStoreConfig<State, Metadata>;
-    /**
-     * execute when the store is initialized
-     */
-    protected onInit?: (args: StoreAPI) => void;
-    protected onStateChanged?: (args: StoreAPI & StateChanges<State>) => void;
-    protected onSubscribed?: (args: StoreAPI) => void;
-    /**
-     * Every time a state change is triggered and before the state is updated, it allows to prevent the state change by returning true
-     */
-    protected computePreventStateChange?: (parameters: StoreAPI & StateChanges<State>) => boolean;
-    /**
-     * We use a wrapper in order to be able to force the state update when necessary even with primitive types
-     */
-    protected stateWrapper: {
+    stateWrapper: {
         state: State;
     };
-    /**
-     * @deprecated direct modifications of the state could end up in unexpected behaviors
-     */
-    protected get state(): State;
     constructor(state: State);
-    constructor(state: State, config: GlobalStoreConfig<State, Metadata>);
-    constructor(state: State, config: GlobalStoreConfig<State, Metadata>, actionsConfig: ActionsConfig);
+    constructor(state: State, args: {
+        metadata?: Metadata;
+        callbacks?: GlobalStoreCallbacks<State, Metadata>;
+        actions?: ActionsConfig;
+        name?: string;
+    });
+    protected onInit?: (args: StoreTools<State, Metadata>) => void;
+    protected onStateChanged?: (args: StoreTools<State, Metadata> & StateChanges<State>) => void;
+    protected onSubscribed?: (args: StoreTools<State, Metadata>) => void;
+    protected computePreventStateChange?: (parameters: StoreTools<State, Metadata> & StateChanges<State>) => boolean;
     protected initialize: () => Promise<void>;
-    protected executeSetStateForSubscriber: (subscription: SubscriberParameters, { forceUpdate, newRootState, currentRootState, identifier, }: {
-        forceUpdate: boolean;
+    protected executeSetStateForSubscriber: (subscription: SubscriberParameters, args: {
+        forceUpdate: boolean | undefined;
         newRootState: State;
-        currentRootState: State;
-        identifier: string;
-    }) => void;
+        currentRootState: State | UniqueSymbol;
+        identifier: string | undefined;
+    }) => {
+        didUpdate: boolean;
+    };
     /**
      * set the state and update all the subscribers
      * @param {StateSetter<State>} setter - The setter function or the value to set
      * */
-    protected setState: ({ state: newRootState, forceUpdate, identifier, }: {
+    protected setState: ({ state: newRootState, }: {
         state: State;
-        forceUpdate: boolean;
-        identifier?: string;
+    }, { forceUpdate, identifier }: {
+        forceUpdate?: boolean | undefined;
+        identifier?: string | undefined;
     }) => void;
     /**
      * Set the value of the metadata property, this is no reactive and will not trigger a re-render
@@ -66,56 +49,50 @@ export declare class GlobalStore<State, Metadata extends BaseMetadata, ActionsCo
      * */
     protected setMetadata: MetadataSetter<Metadata>;
     protected getMetadata: () => Metadata;
-    protected createChangesSubscriber: ({ callback, selector, config, }: {
-        selector?: SelectorCallback<unknown, unknown>;
-        callback: SubscribeCallback<unknown>;
-        config: SubscribeCallbackConfig<unknown>;
-    }) => {
-        stateWrapper: {
-            state: unknown;
-        };
-        subscriptionCallback: SubscriptionCallback;
-    };
-    protected getState: StateGetter<State>;
+    getState: StateGetter<State>;
     /**
-     * get the parameters object to pass to the callback functions (onInit, onStateChanged, onSubscribed, computePreventStateChange)
+     * get the parameters object to pass to the callback functions:
+     * onInit, onStateChanged, onSubscribed, computePreventStateChange
      * */
-    protected getConfigCallbackParam: () => StoreAPI;
-    protected lastSubscriptionId: string;
-    /**
-     * Returns the new subscription when added or false if the subscription was updated
-     */
-    protected updateSubscriptionArgs: (subscriptionId: string, item: Partial<SubscriberParameters>) => false | Partial<SubscriberParameters>;
+    getConfigCallbackParam: () => StoreTools<State, Metadata>;
+    protected lastSubscriptionId: string | null;
+    protected setOrUpdateSubscription: (subscription: SubscriberParameters) => {
+        isNewSubscription?: boolean;
+    };
+    protected partialUpdateSubscription: (subscriptionId: string, values: Partial<SubscriberParameters>) => void;
     protected executeOnSubscribed: () => void;
     /**
      * Returns a custom hook that allows to handle a global state
      * @returns {[State, StateMutator, Metadata]} - The state, the state setter or the actions map, the metadata
      * */
     getHook: () => StateHook<State, PublicStateMutator, Metadata>;
+    protected computeSelectedState: ({ selector, subscriptionId, config, currentDependencies, computeChildState, stateWrapperRef, }: {
+        selector: SelectorCallback<unknown, unknown> | undefined;
+        subscriptionId: string;
+        config: UseHookConfig<unknown, unknown>;
+        currentDependencies: unknown[] | undefined;
+        computeChildState: () => {
+            state: unknown;
+        };
+        stateWrapperRef: {
+            state: unknown;
+        };
+    }) => unknown;
     /**
      * @description
      * Use this function to create a custom global hook which contains a fragment of the state of another hook
      */
-    createSelectorHook: <RootState, StateMutator, Metadata_1 extends BaseMetadata, RootSelectorResult, RootDerivate = RootSelectorResult extends never ? RootState : RootSelectorResult>(mainSelector?: (state: RootState) => RootSelectorResult, { isEqualRoot: mainIsEqualRoot, isEqual: mainIsEqualFun, name: selectorName, }?: {
-        isEqual?: (current: RootDerivate, next: RootDerivate) => boolean;
-        isEqualRoot?: (current: RootState, next: RootState) => boolean;
-        name?: string;
+    createSelectorHook: <RootState, StateMutator, Metadata_1 extends BaseMetadata, RootSelectorResult, RootDerivate = RootSelectorResult extends never ? RootState : RootSelectorResult>(mainSelector: (state: RootState) => RootSelectorResult, { isEqualRoot: mainIsEqualRoot, isEqual: mainIsEqualFun, name: selectorName, }?: {
+        isEqual?: ((current: RootDerivate, next: RootDerivate) => boolean) | undefined;
+        isEqualRoot?: ((current: RootState, next: RootState) => boolean) | undefined;
+        name?: string | undefined;
     }) => StateHook<RootDerivate, StateMutator, Metadata_1>;
-    /**
-     * Returns an array with the a function to get the state, the state setter or the actions map, and a function to get the metadata
-     * @returns {[() => State, StateMutator, () => Metadata]} - The state getter, the state setter or the actions map, the metadata getter
-     * */
-    stateControls: () => [StateGetter<State>, PublicStateMutator, MetadataGetter<Metadata>];
+    stateControls: () => [retriever: StateGetter<State>, mutator: PublicStateMutator, metadata: MetadataGetter<Metadata>];
     /**
      * Returns the state setter or the actions map
      * @returns {StateMutator} - The state setter or the actions map
      * */
     protected getStateOrchestrator: () => PublicStateMutator;
-    /**
-     * Calculate whenever or not we should compute the callback parameters on the state change
-     * @returns {boolean} - True if we should compute the callback parameters on the state change
-     * */
-    protected hasStateCallbacks: () => boolean;
     /**
      * This is responsible for defining whenever or not the state change should be allowed or prevented
      * the function also execute the functions:
@@ -127,5 +104,10 @@ export declare class GlobalStore<State, Metadata extends BaseMetadata, ActionsCo
      * This creates a map of actions that can be used to modify or interact with the state
      * @returns {ActionCollectionResult<State, Metadata, StateMutator>} - The actions map result of the configuration object passed to the constructor
      * */
-    protected getStoreActionsMap: () => ActionCollectionResult<State, Metadata, ActionsConfig>;
+    getStoreActionsMap: () => null | ActionCollectionResult<State, Metadata, NonNullable<ActionsConfig>>;
+    createObservable<Fragment>(mainSelector: (state: State) => Fragment, { isEqualRoot: mainIsEqualRoot, isEqual: mainIsEqualFun, name: selectorName, }?: {
+        isEqual?: (current: Fragment, next: Fragment) => boolean;
+        isEqualRoot?: (current: State, next: State) => boolean;
+        name?: string;
+    }): ObservableFragment<Fragment>;
 }

package/lib/src/GlobalStore.functionHooks.d.ts

@@ -1,125 +1,38 @@
-import { ActionCollectionConfig, StateSetter, ActionCollectionResult, UseHookConfig, UnsubscribeCallback, StateHook, StateGetter, CustomGlobalHookBuilderParams, SelectorCallback, SubscribeToEmitter, StateChanges, BaseMetadata, MetadataSetter, StoreTools } from './GlobalStore.types';
-/**
- * Creates a global hook that can be used to access the state and actions across the application
- * @returns {} - () => [TState, Setter, TMetadata] the hook that can be used to access the state and the setter of the state
- */
-export declare const createGlobalState: {
+import { ActionCollectionConfig, StateSetter, ActionCollectionResult, StateHook, CustomGlobalHookBuilderParams, BaseMetadata, GlobalStoreCallbacks } from './GlobalStore.types';
+export interface CreateGlobalState {
     <State>(state: State): StateHook<State, StateSetter<State>, BaseMetadata>;
-    <State_1, Metadata extends BaseMetadata, ActionsConfig extends {} | ActionCollectionConfig<State_1, Metadata> = null, StoreAPI = {
-        setMetadata: MetadataSetter<Metadata>;
-        setState: StateSetter<State_1>;
-        getState: StateGetter<State_1>;
-        getMetadata: () => Metadata;
-        actions: ActionsConfig extends null ? null : Record<string, (...args: any[]) => void>;
-    }>(state: State_1, config: Readonly<{
-        /**
-         * @deprecated We needed to move the actions parameter as a third argument to fix several issues with the type inference of the actions
-         */
+    <State, Metadata extends BaseMetadata | unknown, ActionsConfig extends ActionCollectionConfig<State, Metadata> | null | {}, PublicStateMutator = keyof ActionsConfig extends never | undefined ? StateSetter<State> : ActionCollectionResult<State, Metadata, NonNullable<ActionsConfig>>>(state: State, args: {
+        name?: string;
+        metadata?: Metadata;
+        callbacks?: GlobalStoreCallbacks<State, Metadata>;
         actions?: ActionsConfig;
-        /**
-         * Non reactive information about the state
-         */
+    }): StateHook<State, PublicStateMutator, Metadata>;
+    <State, Metadata extends BaseMetadata | unknown, ActionsConfig extends ActionCollectionConfig<State, Metadata>>(state: State, args: {
+        name?: string;
         metadata?: Metadata;
-        /**
-         * executes immediately after the store is created
-         * */
-        onInit?: (args: StoreAPI) => void;
-        onStateChanged?: (args: StoreAPI & StateChanges<State_1>) => void;
-        onSubscribed?: (args: StoreAPI) => void;
-        /**
-         * callback function called every time the state is about to change and it allows you to prevent the state change
-         */
-        computePreventStateChange?: (args: StoreAPI & StateChanges<State_1>) => boolean;
-    }>): StateHook<State_1, ActionsConfig extends null ? StateSetter<State_1> : ActionCollectionResult<State_1, Metadata, ActionsConfig>, Metadata>;
-    <State_2, Metadata_1 extends BaseMetadata, ActionsConfig_1 extends ActionCollectionConfig<State_2, Metadata_1>, StoreAPI_1 = {
-        setMetadata: MetadataSetter<Metadata_1>;
-        setState: StateSetter<State_2>;
-        getState: StateGetter<State_2>;
-        getMetadata: () => Metadata_1;
-        actions: Record<string, (...args: any[]) => void>;
-    }>(state: State_2, config: Readonly<{
-        /**
-         * Non reactive information about the state
-         */
-        metadata?: Metadata_1;
-        /**
-         * executes immediately after the store is created
-         * */
-        onInit?: (args: StoreAPI_1) => void;
-        onStateChanged?: (args: StoreAPI_1 & StateChanges<State_2>) => void;
-        onSubscribed?: (args: StoreAPI_1) => void;
-        /**
-         * callback function called every time the state is about to change and it allows you to prevent the state change
-         */
-        computePreventStateChange?: (args: StoreAPI_1 & StateChanges<State_2>) => boolean;
-    }>, actions: ActionsConfig_1): StateHook<State_2, ActionCollectionResult<State_2, Metadata_1, ActionsConfig_1>, Metadata_1>;
-    <State_3, Metadata_2 extends BaseMetadata, ActionsConfig_2 extends ActionCollectionConfig<State_3, Metadata_2>, StoreAPI_2 = {
-        setMetadata: MetadataSetter<Metadata_2>;
-        setState: StateSetter<State_3>;
-        getState: StateGetter<State_3>;
-        getMetadata: () => Metadata_2;
-    }>(state: State_3, builder: () => ActionsConfig_2, config?: Readonly<{
-        /**
-         * Non reactive information about the state
-         */
-        metadata?: Metadata_2;
-        /**
-         * executes immediately after the store is created
-         * */
-        onInit?: (args: StoreAPI_2) => void;
-        onStateChanged?: (args: StoreAPI_2 & StateChanges<State_3>) => void;
-        onSubscribed?: (args: StoreAPI_2) => void;
-        /**
-         * callback function called every time the state is about to change and it allows you to prevent the state change
-         */
-        computePreventStateChange?: (args: StoreAPI_2 & StateChanges<State_3>) => boolean;
-    }>): StateHook<State_3, ActionCollectionResult<State_3, Metadata_2, ActionsConfig_2>, Metadata_2>;
-};
-/**
- * @description
- * Use this function to create a custom global store.
- * You can use this function to create a store with async storage.
- */
-export declare const createCustomGlobalState: <InheritMetadata, TCustomConfig>({ onInitialize, onChange, }: CustomGlobalHookBuilderParams<InheritMetadata, TCustomConfig>) => <State, Metadata, ActionsConfig extends Readonly<ActionCollectionConfig<State, Metadata & InheritMetadata>> = null>(state: State, _config?: Readonly<{
-    metadata?: Metadata & InheritMetadata;
-    readonly actions?: Readonly<ActionsConfig>;
-    onInit?: (args: StoreTools<State, Metadata & InheritMetadata>) => void;
-    onStateChanged?: (args: StoreTools<State, Metadata & InheritMetadata> & StateChanges<State>) => void;
-    onSubscribed?: (parameters: StoreTools<State, Metadata & InheritMetadata>) => void;
-    computePreventStateChange?: (args: StoreTools<State, Metadata & InheritMetadata> & StateChanges<State>) => boolean;
-    /**
-     * @description
-     * Type of the configuration object that the custom hook will require or accept
-     */
-    config?: TCustomConfig;
-}>) => StateHook<State, ActionsConfig extends null ? StateSetter<State> : ActionCollectionResult<State, Metadata & InheritMetadata, ActionsConfig>, Metadata & InheritMetadata>;
-/**
- * @description
- * Use this function to create a custom global store.
- * You can use this function to create a store with async storage.
- * @deprecated
- */
-export declare const createCustomGlobalStateWithDecoupledFuncs: <InheritMetadata, TCustomConfig>({ onInitialize, onChange, }: CustomGlobalHookBuilderParams<InheritMetadata, TCustomConfig>) => <State, Metadata, ActionsConfig extends Readonly<ActionCollectionConfig<State, Metadata & InheritMetadata>> = null>(state: State, _config?: Readonly<{
-    metadata?: Metadata & InheritMetadata;
-    readonly actions?: Readonly<ActionsConfig>;
-    onInit?: (args: StoreTools<State, Metadata & InheritMetadata>) => void;
-    onStateChanged?: (args: StoreTools<State, Metadata & InheritMetadata> & StateChanges<State>) => void;
-    onSubscribed?: (parameters: StoreTools<State, Metadata & InheritMetadata>) => void;
-    computePreventStateChange?: (args: StoreTools<State, Metadata & InheritMetadata> & StateChanges<State>) => boolean;
-    /**
-     * @description
-     * Type of the configuration object that the custom hook will require or accept
-     */
-    config?: TCustomConfig;
-}>) => StateHook<State, ActionsConfig extends null ? StateSetter<State> : ActionCollectionResult<State, Metadata & InheritMetadata, ActionsConfig>, Metadata & InheritMetadata>;
-/**
- * @description
- * Use this function to create a custom global hook which contains a fragment of the state of another hook
- */
-export declare const createDerivate: <RootState, StateMutator, Metadata, RootSelectorResult, RootDerivate = RootSelectorResult extends never ? RootState : RootSelectorResult>(useHook: StateHook<RootState, StateMutator, Metadata>, mainSelector?: (state: RootState) => RootSelectorResult, args?: Omit<UseHookConfig<RootDerivate, RootState>, "dependencies">) => StateHook<RootDerivate, StateMutator, Metadata>;
+        callbacks?: GlobalStoreCallbacks<State, Metadata>;
+        actions: ActionsConfig;
+    }): StateHook<State, ActionCollectionResult<State, Metadata, ActionsConfig>, Metadata>;
+}
+export declare const createGlobalState: CreateGlobalState;
+export interface CustomCreateGlobalState<TCustomConfig extends BaseMetadata | unknown, InheritMetadata extends BaseMetadata | unknown = BaseMetadata> {
+    <State>(state: State): StateHook<State, StateSetter<State>, BaseMetadata>;
+    <State, Metadata extends BaseMetadata | unknown, ActionsConfig extends ActionCollectionConfig<State, InheritMetadata & Metadata> | null | {}, PublicStateMutator = keyof ActionsConfig extends never | undefined ? StateSetter<State> : ActionCollectionResult<State, InheritMetadata & Metadata, NonNullable<ActionsConfig>>>(state: State, args: {
+        name?: string;
+        metadata?: Metadata;
+        callbacks?: GlobalStoreCallbacks<State, InheritMetadata & Metadata>;
+        actions?: ActionsConfig;
+        config?: TCustomConfig;
+    }): StateHook<State, PublicStateMutator, InheritMetadata & Metadata>;
+    <State, Metadata extends BaseMetadata | unknown, ActionsConfig extends Readonly<ActionCollectionConfig<State, InheritMetadata & Metadata>>>(state: State, args: {
+        name?: string;
+        metadata?: Metadata;
+        callbacks?: GlobalStoreCallbacks<State, InheritMetadata & Metadata>;
+        actions: ActionsConfig;
+        config?: TCustomConfig;
+    }): StateHook<State, ActionCollectionResult<State, InheritMetadata & Metadata, ActionsConfig>, InheritMetadata & Metadata>;
+}
 /**
- * @description
- * This function allows you to create a derivate emitter
- * With this approach, you can subscribe to changes in a specific fragment or subset of the state.
+ * @description Simple custom global state hook builder
  */
-export declare const createDerivateEmitter: <TDerivate, TStateRetriever extends StateGetter<unknown>, TState = Exclude<ReturnType<TStateRetriever>, UnsubscribeCallback>>(getter: TStateRetriever, selector: SelectorCallback<TState, TDerivate>) => SubscribeToEmitter<TDerivate>;
+export declare const createCustomGlobalState: <TCustomConfig extends unknown, InheritMetadata extends unknown = BaseMetadata>({ onInitialize, onChange, }: CustomGlobalHookBuilderParams<TCustomConfig, InheritMetadata>) => CustomCreateGlobalState<TCustomConfig, InheritMetadata>;