import { TState } from "thorium-states";
import { _HUID } from 'thorium-huid';
export type TStoreStateToken = `${string}-${string}-${string}-${string}-${string}`;
/** L'interface `IStoreState<T>` définit la structure d'un état d'un magasin. */
export interface IStoreState<T> {
    /** La propriété `token: TStoreStateToken;` dans l'interface `IStoreState<T>` est utilisée pour identifier de manière unique
    un objet d'état du magasin. Chaque objet d'état aura un jeton différent, permettant ainsi de les identifier et de les récupérer facilement.
    Par exemple, un jeton pourrait être un identifiant unique pour un utilisateur. */
    token: TStoreStateToken;
    /** La propriété `key: string;` dans l'interface `IStoreState<T>` est utilisée pour identifier un objet d'état spécifique au sein d'un contexte de magasin.
    Chaque objet d'état aura une clé unique, permettant ainsi de le repérer, de le mettre à jour ou de le supprimer dans le contexte du magasin.
    Par exemple, une clé pourrait être "utilisateurCourant". */
    key: string;
    /** La propriété `state: State<T>` dans l'interface `IStoreState<T>` est utilisée pour stocker la valeur d'un objet d'état du magasin.
    Le type `State<T>` représente la valeur actuelle et permet de s'abonner aux changements de cette valeur.
    Par exemple, cette propriété pourrait contenir l'état actuel d'un utilisateur, tel que ses informations personnelles. */
    state: TState<T>;
    /** La propriété `value: T;` dans l'interface `IStoreState<T>` est utilisée pour stocker la valeur actuelle de
    l'état dans un objet d'état de magasin. Elle représente le type de la valeur d'état, et permet d'accéder et de mettre à jour cette valeur dans le
    contexte du magasin. Par exemple, cette propriété pourrait contenir le nom d'un utilisateur. */
    value: T;
    /** La propriété `setter` dans l'interface `IStoreState<T>` est une fonction qui prend une valeur de type
    `T` et renvoie une valeur de type `T`. Elle est utilisée pour mettre à jour la valeur d'un objet d'état du magasin.
    Par exemple, vous pouvez utiliser cette fonction pour modifier les informations d'un utilisateur en fournissant de nouvelles informations. */
    setter(value: T): T;
    /** La ligne `subscribe: State<T>['subscribe'];` définit la propriété `subscribe` dans l'interface
    `IStoreState<T>`. Il fait référence à la méthode `subscribe` du type `State<T>`.
    Par exemple, vous pouvez utiliser cette méthode pour vous abonner aux changements de l'état d'un utilisateur
    et être notifié lorsque des modifications sont apportées. */
    subscribe: TState<T>['subscribe'];
    /** La ligne `unsubscribe: State<T>['unsubscribe'];` dans l'interface `IStoreState<T>` définit la
    propriété `unsubscribe`. Il fait référence à la méthode `unsubscribe` du type `State<T>`.
    Par exemple, vous pouvez utiliser cette méthode pour annuler votre abonnement aux changements de
    l'état d'un utilisateur si vous n'avez plus besoin de recevoir des notifications. */
    unsubscribe: TState<T>['unsubscribe'];
    /** La propriété `delete: State<T>['delete'];` est utilisée pour supprimer un objet d'état du magasin. Elle fait référence
    à la méthode `delete` du type `State<T>`. Par exemple, si vous souhaitez supprimer complètement l'état d'un utilisateur du contexte du magasin,
    vous pouvez utiliser cette méthode en fournissant la clé de l'utilisateur comme argument. */
    delete: TState<T>['delete'];
}
/** Le type `TStoreContextEvent` est une union de chaînes de caractères ('add', 'update', 'delete')
 * qui représente les événements possibles dans un contexte de magasin (store context). Ces événements
 * sont utilisés pour notifier les changements sur les données stockées dans le contexte du magasin.
 * Par exemple, lorsque de nouvelles données sont ajoutées ('add'), existantes sont mises à jour ('update'),
 * ou supprimées ('delete').
 *
 * ## Exemple :
 * ```typescript
 * const event: TStoreContextEvent = 'add';
 * ```
*/
export type TStoreContextEvent = 'add' | 'update' | 'delete';
/** L'interface `IStoreContext` définit la structure et les méthodes qu'un objet contexte de magasin devrait avoir. */
export interface IStoreContext {
    /**
     * La propriété `uuid:TStoreUUID;` définit une propriété appelée `uuid` dans l'interface `IStoreContext`. Le type
     * de cette propriété est `TStoreUUID`, qui est une chaîne de caractères. Cette propriété est utilisée pour identifier
     * de manière unique un objet contexte de magasin.
    */
    uuid: TStoreUUID;
    /**
     * La propriété `huid:_HUID;` définit une propriété appelée `huid` dans l'interface `IStoreContext`. Le type
     * de cette propriété est `_HUID`, qui est un identifiant unique hiérarchique.
    */
    huid: _HUID;
    /**
     * La propriété `unid:string;` définit une propriété appelée `unid` dans l'interface `IStoreContext`. Cette propriété
     * est une chaîne de caractères et est utilisée comme identifiant unique pour le contexte de magasin. Elle se compose
     * du `huid` et du `name`.
    */
    unid: string;
    /**
     * La propriété `name:string;` définit une propriété appelée `name` dans l'interface `IStoreContext`. Cette propriété
     * est une chaîne de caractères et représente le nom du contexte de magasin.
    */
    name: string;
    /**
     * La propriété `root:IStoreContext;` définit une propriété appelée `root` dans l'interface `IStoreContext`. Cette propriété
     * est de type `IStoreContext` et représente le contexte racine du magasin.
    */
    root: IStoreContext;
    /**
     * La propriété `states:IStoreState<any>[]` définit une propriété appelée `states` dans l'interface `IStoreContext`. Cette
     * propriété est un tableau d'objets de type `IStoreState<any>` et représente les états stockés dans le contexte de magasin.
    */
    states: IStoreState<any>[];
    /**
     * La méthode `keyList` dans l'interface `IStoreContext` est une fonction qui renvoie un tableau de chaînes de caractères. Cette
     * méthode est utilisée pour récupérer la liste de toutes les clés ou identifiants des valeurs d'état dans un contexte de magasin. Chaque
     * valeur d'état dans le contexte de magasin est associée à un jeton unique, et cette méthode vous permet d'obtenir toutes ces clés.
    */
    tokenList(): TStoreStateToken[];
    /**
     * La méthode `keyList` dans l'interface `IStoreContext` est une fonction qui renvoie un tableau de chaînes de caractères. Cette
     * méthode est utilisée pour récupérer la liste de toutes les clés ou identifiants des valeurs d'état dans un contexte de magasin. Chaque
     * valeur d'état dans le contexte de magasin est associée à une clé unique, et cette méthode vous permet d'obtenir toutes ces clés.
    */
    keyList(): string[];
    /**
     * La méthode `values` dans la classe `StoreContext` est une fonction qui renvoie un tableau d'objets `IStoreState<any>`.
    */
    values(): IStoreState<any>[];
    /**
     * La méthode `set` dans la classe `StoreContext` est une méthode générique qui prend une `clé` de type `string` et une `valeur` de type `T`.
     * Elle est utilisée pour ajouter une nouvelle valeur d'état au contexte de magasin.
    */
    set<T>(key: string, value: T): IStoreState<T>;
    /**
     * La méthode `get` dans la classe `StoreContext` prend un `identificateur` de type `string|TStoreStateToken` et renvoie un objet `IStoreState<T>`.
    */
    get<T>(identificateur: string | TStoreStateToken): IStoreState<T>;
    /** La méthode `update` dans la classe `StoreContext` prend un `identificateur` de type `string|TStoreStateToken` et une `valeur` de type `any`. */
    update(identificateur: string | TStoreStateToken, value: any): any;
    /** La méthode `remove` dans la classe `StoreContext` prend un `identificateur` de type `string|TStoreStateToken`. */
    remove(identificateur: string | TStoreStateToken): any;
    /**
     * La méthode `on` dans la classe `StoreContext` est utilisée pour enregistrer des écouteurs d'événements pour des
     * événements spécifiques dans le contexte de magasin. Elle prend deux paramètres : `event` et `callback`.
    */
    on(event: TStoreContextEvent, callback: (oldValue: any, newValue: any) => void): void;
    /** La méthode `extends` dans la classe `StoreContext` permet d'étendre le contexte de magasin actuel en créant un nouveau contexte avec le nom spécifié. */
    extends(contextName: string, options?: StoreContextOptions): IStoreContext;
    /** La méthode `destroy` dans la classe `StoreContext` renvoie un booléen pour indiquer si la destruction du contexte a réussi. */
    destroy(): boolean;
}
export interface StoreContextOptions {
    /** La propriété `parentStoreId?: _HUID;` est une option qui permet de spécifier l'identifiant du magasin parent, s'il existe. */
    parentStoreId?: _HUID;
    /**
     * La propriété `ondelete?: (storeContext: IStoreContext, stateDeletionResult: boolean[]) => void;` est une option qui permet
     * de spécifier une fonction de rappel qui sera appelée lors de la suppression du contexte de magasin ou de ses états. Cette fonction
     * prend le contexte de magasin en cours et un tableau de résultats de suppression d'états en tant que paramètres.
    */
    ondelete?(storeContext: IStoreContext, stateDeletionResult: boolean[]): void;
}
/** The `StoreContext` class is an implementation of the `IStoreContext` interface in TypeScript,
providing methods for managing a store of state values. */
export declare const StoreContextFactory: (contextName: string, options?: StoreContextOptions) => {
    storeId: `${string}-${string}-${string}-${string}-${string}`;
    store: {
        new (): {
            "__#2@#_uuid": TStoreUUID;
            readonly uuid: `${string}-${string}-${string}-${string}-${string}`;
            "__#2@#_huid": _HUID;
            readonly huid: _HUID;
            readonly parent: IStoreContext;
            readonly children: IStoreContext[];
            readonly name: string;
            readonly unid: string;
            readonly isDetatch: boolean;
            readonly isRoot: boolean;
            readonly root: any;
            readonly states: IStoreState<any>[];
            /**
             * La propriété `#_events` est une variable privée de type `Record<TStoreContextEvent, ((x, y) => void) | null>`.
             * Cela signifie qu'elle représente un ensemble d'événements possibles dans le contexte du magasin, tels que 'add', 'update' ou 'delete'.
             * Chaque événement peut avoir une fonction de rappel qui prend deux paramètres `(x, y)` et retourne `void`, ou être nulle (null) s'il n'y a pas de rappel pour cet événement.
            */
            "__#2@#_events": Record<TStoreContextEvent, (x: any, y: any) => void>;
            readonly events: Record<TStoreContextEvent, (x: any, y: any) => void>;
            /**
             * La variable privée `#_list` est initialisée avec une nouvelle instance de la structure de données Map.
             * En TypeScript, Map est un objet qui permet de stocker des données sous forme de paires clé-valeur.
             * Dans ce contexte, les clés sont de type `TStoreStateToken` et les valeurs sont de type `IStoreState<any>`.
             * Cette Map est utilisée pour stocker les états du magasin.
            */
            "__#2@#_list": Map<TStoreStateToken, IStoreState<any>>;
            readonly list: Map<`${string}-${string}-${string}-${string}-${string}`, IStoreState<any>>;
            set<T>(key: string, value: any): IStoreState<T>;
            get<T_1>(identificateur: string | TStoreStateToken): IStoreState<T_1>;
            update(identificateur: string | TStoreStateToken, value: any): IStoreState<any>[] | Map<`${string}-${string}-${string}-${string}-${string}`, IStoreState<any>>[];
            remove(identificateur: string | TStoreStateToken): boolean[];
            tokenList(): `${string}-${string}-${string}-${string}-${string}`[];
            keyList(): string[];
            values(): IStoreState<any>[];
            on(event: TStoreContextEvent, callback: (oldValue: any, newValue: any) => void): void;
            extends(contextName: string, options?: StoreContextOptions): IStoreContext;
            destroy(): boolean;
        };
    };
};
export type TStoreUUID = `${string}-${string}-${string}-${string}-${string}`;
export interface IStoreContextAPI {
    /**
     * Crée un nouveau contexte de magasin avec le nom spécifié et les options facultatives.
     * @param contextName Le nom du contexte de magasin.
     * @param options (Facultatif) Les options pour la création du contexte.
     * @returns Le nouveau contexte de magasin créé.
     * ## Example
     * ```typescript
     * const newContext = storeContext().create("NouveauContext");
     * ```
    */
    create(contextName: string, options?: StoreContextOptions): TStoreContext;
    /**
     * Supprime un contexte de magasin existant avec l'UUID spécifié.
     * @param storeUuid L'UUID du contexte de magasin à supprimer.
     * @returns Vrai si le contexte de magasin a été supprimé avec succès, sinon faux.
     * ## Example
     * ```typescript
     * const uuidToDelete = "xxxxxxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"; // Remplacez par l'UUID du contexte à supprimer.
     * const deleted = storeContext().delete(uuidToDelete);
     * ```
    */
    delete(storeUuid: TStoreUUID): boolean;
    /**
     * Récupère un contexte de magasin par son UUID.
     * @param storeUuid L'UUID du contexte de magasin à récupérer.
     * @returns Le contexte de magasin correspondant à l'UUID, ou null s'il n'existe pas.
     * ## Example
     * ```typescript
     * const uuidToRetrieve = "xxxxxxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"; // Remplacez par l'UUID du contexte à récupérer.
     * const retrievedContext = storeContext().getContextById(uuidToRetrieve);
     * ```
    */
    getContextById(storeUuid: TStoreUUID): IStoreContext;
    /**
     * Récupère un contexte de magasin par son HUID (Hierarchical Unique Identifier).
     * @param storeHuid L'HUID du contexte de magasin à récupérer.
     * @returns Le contexte de magasin correspondant à l'HUID, ou null s'il n'existe pas.
     * ## Example
     * ```typescript
     * const huidToRetrieve = new _HUUID("xxxxxxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx") // Remplacez par l'HUID du contexte à récupérer.
     * const retrievedContext = storeContext().getContextByHuid(huidToRetrieve);
     * ```
    */
    getContextByHuid(storeHuid: _HUID): IStoreContext;
    /**
     * Récupère un contexte de magasin par son UNID (Unique Identifier).
     * @param storeUnid L'UNID du contexte de magasin à récupérer.
     * @returns Le contexte de magasin correspondant à l'UNID, ou null s'il n'existe pas.
     * ## Example
     * ```typescript
     * const unidToRetrieve = "xxxxxxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx-MyContext"; // Remplacez par l'UNID du contexte à récupérer.
     * const retrievedContext = storeContext().getContextByUnid(unidToRetrieve);
     * ```
    */
    getContextByUnId(storeUnid: string): IStoreContext;
    /**
     * Récupère tous les contextes de magasin avec le nom spécifié.
     * @param contextName Le nom des contextes de magasin à récupérer.
     * @returns Un tableau de tous les contextes de magasin correspondant au nom.
     * ## Example
     * ```typescript
     * const nameToRetrieve = "MyContext"; // Remplacez par le nom du contexte à récupérer.
     * const retrievedContexts = storeContext().getContextByName(nameToRetrieve);
     * ```
    */
    getContextByName(contextName: string): IStoreContext[];
    /**
     * Récupère le contexte parent d'un contexte de magasin par son HUID.
     * @param storeHuid L'HUID du contexte de magasin pour lequel vous souhaitez trouver le contexte parent.
     * @returns Le contexte parent correspondant à l'HUID, ou null s'il n'existe pas.
     * ## Example
     * ```typescript
     * const huidToFindParent = new _HUUID('xxxxxxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'); // Remplacez par l'HUID du contexte fils.
     * const parentContext = storeContext().getParentContext(huidToFindParent);
     * ```
    */
    getParentContext(storeHuid: _HUID): IStoreContext;
    /**
     * Récupère les contextes enfants d'un contexte de magasin par son HUID.
     * @param storeHuid L'HUID du contexte de magasin pour lequel vous souhaitez trouver les contextes enfants.
     * @returns Un tableau de contextes enfants correspondant à l'HUID.
     * ## Example
     * ```typescript
     * const huidToFindChildren = new _HUUID('xxxxxxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'); // Remplacez par l'HUID du contexte parent.
     * const childrenContexts = storeContext().getChildrenContext(huidToFindChildren);
     * ```
    */
    getChildrenContext(storeHuid: _HUID): IStoreContext[];
}
/** La fonction `storeContext` retourne une instance de l'interface `IStoreContextAPI` qui permet d'interagir avec les contextes de magasin. */
export declare function storeContext(): IStoreContextAPI;
/** La fonction `listContext` affiche la liste des contextes de magasin sous forme de tableau dans la console. Elle extrait les valeurs de tous les contextes de magasin disponibles dans `StoreStack` et les affiche sous forme tabulaire. */
export declare function listContext(): void;
export declare const createStoreContext: (contextName: string, options?: StoreContextOptions) => TStoreContext;
export declare const deleteStoreContext: (storeUuid: TStoreUUID) => boolean;
export type TStoreContext = IStoreContext;