init

node_modules/pinia/dist/pinia.d.ts

@@ -0,0 +1,986 @@
+import { App } from 'vue-demi';
+import { ComputedRef } from 'vue-demi';
+import type { DebuggerEvent } from 'vue-demi';
+import { EffectScope } from 'vue-demi';
+import type { Plugin as Plugin_2 } from 'vue-demi';
+import { Ref } from 'vue-demi';
+import { ToRef } from 'vue-demi';
+import { ToRefs } from 'vue-demi';
+import { UnwrapRef } from 'vue-demi';
+import type { WatchOptions } from 'vue-demi';
+
+/**
+ * Creates an _accept_ function to pass to `import.meta.hot` in Vite applications.
+ *
+ * @example
+ * ```js
+ * const useUser = defineStore(...)
+ * if (import.meta.hot) {
+ *   import.meta.hot.accept(acceptHMRUpdate(useUser, import.meta.hot))
+ * }
+ * ```
+ *
+ * @param initialUseStore - return of the defineStore to hot update
+ * @param hot - `import.meta.hot`
+ */
+export declare function acceptHMRUpdate<Id extends string = string, S extends StateTree = StateTree, G extends _GettersTree<S> = _GettersTree<S>, A = _ActionsTree>(initialUseStore: StoreDefinition<Id, S, G, A>, hot: any): (newModule: any) => any;
+
+/**
+ * Type of an object of Actions. For internal usage only.
+ * For internal use **only**
+ */
+export declare type _ActionsTree = Record<string, _Method>;
+
+export declare type _Awaited<T> = T extends null | undefined ? T : T extends object & {
+    then(onfulfilled: infer F): any;
+} ? F extends (value: infer V, ...args: any) => any ? _Awaited<V> : never : T;
+
+/**
+ * Creates a Pinia instance to be used by the application
+ */
+export declare function createPinia(): Pinia;
+
+/**
+ * Recursive `Partial<T>`. Used by {@link Store['$patch']}.
+ *
+ * For internal use **only**
+ */
+export declare type _DeepPartial<T> = {
+    [K in keyof T]?: _DeepPartial<T[K]>;
+};
+
+/**
+ * Options parameter of `defineStore()` for setup stores. Can be extended to
+ * augment stores with the plugin API. @see {@link DefineStoreOptionsBase}.
+ */
+export declare interface DefineSetupStoreOptions<Id extends string, S extends StateTree, G, A> extends DefineStoreOptionsBase<S, Store<Id, S, G, A>> {
+    /**
+     * Extracted actions. Added by useStore(). SHOULD NOT be added by the user when
+     * creating the store. Can be used in plugins to get the list of actions in a
+     * store defined with a setup function. Note this is always defined
+     */
+    actions?: A;
+}
+
+/**
+ * Creates a `useStore` function that retrieves the store instance
+ *
+ * @param id - id of the store (must be unique)
+ * @param options - options to define the store
+ */
+export declare function defineStore<Id extends string, S extends StateTree = {}, G extends _GettersTree<S> = {}, A = {}>(id: Id, options: Omit<DefineStoreOptions<Id, S, G, A>, 'id'>): StoreDefinition<Id, S, G, A>;
+
+/**
+ * Creates a `useStore` function that retrieves the store instance
+ *
+ * @param options - options to define the store
+ */
+export declare function defineStore<Id extends string, S extends StateTree = {}, G extends _GettersTree<S> = {}, A = {}>(options: DefineStoreOptions<Id, S, G, A>): StoreDefinition<Id, S, G, A>;
+
+/**
+ * Creates a `useStore` function that retrieves the store instance
+ *
+ * @param id - id of the store (must be unique)
+ * @param storeSetup - function that defines the store
+ * @param options - extra options
+ */
+export declare function defineStore<Id extends string, SS>(id: Id, storeSetup: () => SS, options?: DefineSetupStoreOptions<Id, _ExtractStateFromSetupStore<SS>, _ExtractGettersFromSetupStore<SS>, _ExtractActionsFromSetupStore<SS>>): StoreDefinition<Id, _ExtractStateFromSetupStore<SS>, _ExtractGettersFromSetupStore<SS>, _ExtractActionsFromSetupStore<SS>>;
+
+/**
+ * Options parameter of `defineStore()` for option stores. Can be extended to
+ * augment stores with the plugin API. @see {@link DefineStoreOptionsBase}.
+ */
+export declare interface DefineStoreOptions<Id extends string, S extends StateTree, G, A> extends DefineStoreOptionsBase<S, Store<Id, S, G, A>> {
+    /**
+     * Unique string key to identify the store across the application.
+     */
+    id: Id;
+    /**
+     * Function to create a fresh state. **Must be an arrow function** to ensure
+     * correct typings!
+     */
+    state?: () => S;
+    /**
+     * Optional object of getters.
+     */
+    getters?: G & ThisType<UnwrapRef<S> & _StoreWithGetters<G> & PiniaCustomProperties> & _GettersTree<S>;
+    /**
+     * Optional object of actions.
+     */
+    actions?: A & ThisType<A & UnwrapRef<S> & _StoreWithState<Id, S, G, A> & _StoreWithGetters<G> & PiniaCustomProperties>;
+    /**
+     * Allows hydrating the store during SSR when complex state (like client side only refs) are used in the store
+     * definition and copying the value from `pinia.state` isn't enough.
+     *
+     * @example
+     * If in your `state`, you use any `customRef`s, any `computed`s, or any `ref`s that have a different value on
+     * Server and Client, you need to manually hydrate them. e.g., a custom ref that is stored in the local
+     * storage:
+     *
+     * ```ts
+     * const useStore = defineStore('main', {
+     *   state: () => ({
+     *     n: useLocalStorage('key', 0)
+     *   }),
+     *   hydrate(storeState, initialState) {
+     *     // @ts-expect-error: https://github.com/microsoft/TypeScript/issues/43826
+     *     storeState.n = useLocalStorage('key', 0)
+     *   }
+     * })
+     * ```
+     *
+     * @param storeState - the current state in the store
+     * @param initialState - initialState
+     */
+    hydrate?(storeState: UnwrapRef<S>, initialState: UnwrapRef<S>): void;
+}
+
+/**
+ * Options passed to `defineStore()` that are common between option and setup
+ * stores. Extend this interface if you want to add custom options to both kinds
+ * of stores.
+ */
+export declare interface DefineStoreOptionsBase<S extends StateTree, Store> {
+}
+
+/**
+ * Available `options` when creating a pinia plugin.
+ */
+export declare interface DefineStoreOptionsInPlugin<Id extends string, S extends StateTree, G, A> extends Omit<DefineStoreOptions<Id, S, G, A>, 'id' | 'actions'> {
+    /**
+     * Extracted object of actions. Added by useStore() when the store is built
+     * using the setup API, otherwise uses the one passed to `defineStore()`.
+     * Defaults to an empty object if no actions are defined.
+     */
+    actions: A;
+}
+
+/**
+ * For internal use **only**
+ */
+export declare type _ExtractActionsFromSetupStore<SS> = SS extends undefined | void ? {} : _ExtractActionsFromSetupStore_Keys<SS> extends keyof SS ? Pick<SS, _ExtractActionsFromSetupStore_Keys<SS>> : never;
+
+/**
+ * Type that enables refactoring through IDE.
+ * For internal use **only**
+ */
+export declare type _ExtractActionsFromSetupStore_Keys<SS> = keyof {
+    [K in keyof SS as SS[K] extends _Method ? K : never]: any;
+};
+
+/**
+ * For internal use **only**
+ */
+export declare type _ExtractGettersFromSetupStore<SS> = SS extends undefined | void ? {} : _ExtractGettersFromSetupStore_Keys<SS> extends keyof SS ? Pick<SS, _ExtractGettersFromSetupStore_Keys<SS>> : never;
+
+/**
+ * Type that enables refactoring through IDE.
+ * For internal use **only**
+ */
+export declare type _ExtractGettersFromSetupStore_Keys<SS> = keyof {
+    [K in keyof SS as SS[K] extends ComputedRef ? K : never]: any;
+};
+
+/**
+ * For internal use **only**
+ */
+export declare type _ExtractStateFromSetupStore<SS> = SS extends undefined | void ? {} : _ExtractStateFromSetupStore_Keys<SS> extends keyof SS ? _UnwrapAll<Pick<SS, _ExtractStateFromSetupStore_Keys<SS>>> : never;
+
+/**
+ * Type that enables refactoring through IDE.
+ * For internal use **only**
+ */
+export declare type _ExtractStateFromSetupStore_Keys<SS> = keyof {
+    [K in keyof SS as SS[K] extends _Method | ComputedRef ? never : K]: any;
+};
+
+/**
+ * Get the currently active pinia if there is any.
+ */
+export declare const getActivePinia: () => Pinia | undefined;
+
+/**
+ * Type of an object of Getters that infers the argument. For internal usage only.
+ * For internal use **only**
+ */
+export declare type _GettersTree<S extends StateTree> = Record<string, ((state: UnwrapRef<S> & UnwrapRef<PiniaCustomStateProperties<S>>) => any) | (() => any)>;
+
+/**
+ * Allows directly using actions from your store without using the composition
+ * API (`setup()`) by generating an object to be spread in the `methods` field
+ * of a component. The values of the object are the actions while the keys are
+ * the names of the resulting methods.
+ *
+ * @example
+ * ```js
+ * export default {
+ *   methods: {
+ *     // other methods properties
+ *     // useCounterStore has two actions named `increment` and `setCount`
+ *     ...mapActions(useCounterStore, { moar: 'increment', setIt: 'setCount' })
+ *   },
+ *
+ *   created() {
+ *     this.moar()
+ *     this.setIt(2)
+ *   }
+ * }
+ * ```
+ *
+ * @param useStore - store to map from
+ * @param keyMapper - object to define new names for the actions
+ */
+export declare function mapActions<Id extends string, S extends StateTree, G extends _GettersTree<S>, A, KeyMapper extends Record<string, keyof A>>(useStore: StoreDefinition<Id, S, G, A>, keyMapper: KeyMapper): _MapActionsObjectReturn<A, KeyMapper>;
+
+/**
+ * Allows directly using actions from your store without using the composition
+ * API (`setup()`) by generating an object to be spread in the `methods` field
+ * of a component.
+ *
+ * @example
+ * ```js
+ * export default {
+ *   methods: {
+ *     // other methods properties
+ *     ...mapActions(useCounterStore, ['increment', 'setCount'])
+ *   },
+ *
+ *   created() {
+ *     this.increment()
+ *     this.setCount(2) // pass arguments as usual
+ *   }
+ * }
+ * ```
+ *
+ * @param useStore - store to map from
+ * @param keys - array of action names to map
+ */
+export declare function mapActions<Id extends string, S extends StateTree, G extends _GettersTree<S>, A>(useStore: StoreDefinition<Id, S, G, A>, keys: Array<keyof A>): _MapActionsReturn<A>;
+
+/**
+ * For internal use **only**
+ */
+export declare type _MapActionsObjectReturn<A, T extends Record<string, keyof A>> = {
+    [key in keyof T]: A[T[key]];
+};
+
+/**
+ * For internal use **only**
+ */
+export declare type _MapActionsReturn<A> = {
+    [key in keyof A]: A[key];
+};
+
+/**
+ * Alias for `mapState()`. You should use `mapState()` instead.
+ * @deprecated use `mapState()` instead.
+ */
+export declare const mapGetters: typeof mapState;
+
+/**
+ * Allows using state and getters from one store without using the composition
+ * API (`setup()`) by generating an object to be spread in the `computed` field
+ * of a component. The values of the object are the state properties/getters
+ * while the keys are the names of the resulting computed properties.
+ * Optionally, you can also pass a custom function that will receive the store
+ * as its first argument. Note that while it has access to the component
+ * instance via `this`, it won't be typed.
+ *
+ * @example
+ * ```js
+ * export default {
+ *   computed: {
+ *     // other computed properties
+ *     // useCounterStore has a state property named `count` and a getter `double`
+ *     ...mapState(useCounterStore, {
+ *       n: 'count',
+ *       triple: store => store.n * 3,
+ *       // note we can't use an arrow function if we want to use `this`
+ *       custom(store) {
+ *         return this.someComponentValue + store.n
+ *       },
+ *       doubleN: 'double'
+ *     })
+ *   },
+ *
+ *   created() {
+ *     this.n // 2
+ *     this.doubleN // 4
+ *   }
+ * }
+ * ```
+ *
+ * @param useStore - store to map from
+ * @param keyMapper - object of state properties or getters
+ */
+export declare function mapState<Id extends string, S extends StateTree, G extends _GettersTree<S>, A, KeyMapper extends Record<string, keyof S | keyof G | ((store: Store<Id, S, G, A>) => any)>>(useStore: StoreDefinition<Id, S, G, A>, keyMapper: KeyMapper): _MapStateObjectReturn<Id, S, G, A, KeyMapper>;
+
+/**
+ * Allows using state and getters from one store without using the composition
+ * API (`setup()`) by generating an object to be spread in the `computed` field
+ * of a component.
+ *
+ * @example
+ * ```js
+ * export default {
+ *   computed: {
+ *     // other computed properties
+ *     ...mapState(useCounterStore, ['count', 'double'])
+ *   },
+ *
+ *   created() {
+ *     this.count // 2
+ *     this.double // 4
+ *   }
+ * }
+ * ```
+ *
+ * @param useStore - store to map from
+ * @param keys - array of state properties or getters
+ */
+export declare function mapState<Id extends string, S extends StateTree, G extends _GettersTree<S>, A, Keys extends keyof S | keyof G>(useStore: StoreDefinition<Id, S, G, A>, keys: readonly Keys[]): _MapStateReturn<S, G, Keys>;
+
+/**
+ * For internal use **only**
+ */
+export declare type _MapStateObjectReturn<Id extends string, S extends StateTree, G extends _GettersTree<S>, A, T extends Record<string, keyof S | keyof G | ((store: Store<Id, S, G, A>) => any)> = {}> = {
+    [key in keyof T]: () => T[key] extends (store: any) => infer R ? R : T[key] extends keyof Store<Id, S, G, A> ? Store<Id, S, G, A>[T[key]] : never;
+};
+
+/**
+ * For internal use **only**
+ */
+export declare type _MapStateReturn<S extends StateTree, G extends _GettersTree<S>, Keys extends keyof S | keyof G = keyof S | keyof G> = {
+    [key in Keys]: () => Store<string, S, G, {}>[key];
+};
+
+/**
+ * Allows using stores without the composition API (`setup()`) by generating an
+ * object to be spread in the `computed` field of a component. It accepts a list
+ * of store definitions.
+ *
+ * @example
+ * ```js
+ * export default {
+ *   computed: {
+ *     // other computed properties
+ *     ...mapStores(useUserStore, useCartStore)
+ *   },
+ *
+ *   created() {
+ *     this.userStore // store with id "user"
+ *     this.cartStore // store with id "cart"
+ *   }
+ * }
+ * ```
+ *
+ * @param stores - list of stores to map to an object
+ */
+export declare function mapStores<Stores extends any[]>(...stores: [...Stores]): _Spread<Stores>;
+
+/**
+ * Interface to allow customizing map helpers. Extend this interface with the
+ * following properties:
+ *
+ * - `suffix`: string. Affects the suffix of `mapStores()`, defaults to `Store`.
+ */
+export declare interface MapStoresCustomization {
+}
+
+/**
+ * Same as `mapState()` but creates computed setters as well so the state can be
+ * modified. Differently from `mapState()`, only `state` properties can be
+ * added.
+ *
+ * @param useStore - store to map from
+ * @param keyMapper - object of state properties
+ */
+export declare function mapWritableState<Id extends string, S extends StateTree, G extends _GettersTree<S>, A, KeyMapper extends Record<string, keyof S>>(useStore: StoreDefinition<Id, S, G, A>, keyMapper: KeyMapper): _MapWritableStateObjectReturn<S, KeyMapper>;
+
+/**
+ * Allows using state and getters from one store without using the composition
+ * API (`setup()`) by generating an object to be spread in the `computed` field
+ * of a component.
+ *
+ * @param useStore - store to map from
+ * @param keys - array of state properties
+ */
+export declare function mapWritableState<Id extends string, S extends StateTree, G extends _GettersTree<S>, A, Keys extends keyof S>(useStore: StoreDefinition<Id, S, G, A>, keys: readonly Keys[]): {
+    [K in Keys]: {
+        get: () => S[K];
+        set: (value: S[K]) => any;
+    };
+};
+
+/**
+ * For internal use **only**
+ */
+export declare type _MapWritableStateObjectReturn<S extends StateTree, T extends Record<string, keyof S>> = {
+    [key in keyof T]: {
+        get: () => S[T[key]];
+        set: (value: S[T[key]]) => any;
+    };
+};
+
+/**
+ * For internal use **only**
+ */
+export declare type _MapWritableStateReturn<S extends StateTree> = {
+    [key in keyof S]: {
+        get: () => S[key];
+        set: (value: S[key]) => any;
+    };
+};
+
+/**
+ * Generic type for a function that can infer arguments and return type
+ *
+ * For internal use **only**
+ */
+export declare type _Method = (...args: any[]) => any;
+
+/**
+ * Possible types for SubscriptionCallback
+ */
+export declare enum MutationType {
+    /**
+     * Direct mutation of the state:
+     *
+     * - `store.name = 'new name'`
+     * - `store.$state.name = 'new name'`
+     * - `store.list.push('new item')`
+     */
+    direct = "direct",
+    /**
+     * Mutated the state with `$patch` and an object
+     *
+     * - `store.$patch({ name: 'newName' })`
+     */
+    patchObject = "patch object",
+    /**
+     * Mutated the state with `$patch` and a function
+     *
+     * - `store.$patch(state => state.name = 'newName')`
+     */
+    patchFunction = "patch function"
+}
+
+/**
+ * Every application must own its own pinia to be able to create stores
+ */
+export declare interface Pinia {
+    install: (app: App) => void;
+    /**
+     * root state
+     */
+    state: Ref<Record<string, StateTree>>;
+    /**
+     * Adds a store plugin to extend every store
+     *
+     * @param plugin - store plugin to add
+     */
+    use(plugin: PiniaPlugin): Pinia;
+    /* Excluded from this release type: _p */
+    /* Excluded from this release type: _a */
+    /* Excluded from this release type: _e */
+    /* Excluded from this release type: _s */
+    /* Excluded from this release type: _testing */
+}
+
+/**
+ * Interface to be extended by the user when they add properties through plugins.
+ */
+export declare interface PiniaCustomProperties<Id extends string = string, S extends StateTree = StateTree, G = _GettersTree<S>, A = _ActionsTree> {
+}
+
+/**
+ * Properties that are added to every `store.$state` by `pinia.use()`.
+ */
+export declare interface PiniaCustomStateProperties<S extends StateTree = StateTree> {
+}
+
+/**
+ * Plugin to extend every store.
+ */
+export declare interface PiniaPlugin {
+    /**
+     * Plugin to extend every store. Returns an object to extend the store or
+     * nothing.
+     *
+     * @param context - Context
+     */
+    (context: PiniaPluginContext): Partial<PiniaCustomProperties & PiniaCustomStateProperties> | void;
+}
+
+/**
+ * Context argument passed to Pinia plugins.
+ */
+export declare interface PiniaPluginContext<Id extends string = string, S extends StateTree = StateTree, G = _GettersTree<S>, A = _ActionsTree> {
+    /**
+     * pinia instance.
+     */
+    pinia: Pinia;
+    /**
+     * Current app created with `Vue.createApp()`.
+     */
+    app: App;
+    /**
+     * Current store being extended.
+     */
+    store: Store<Id, S, G, A>;
+    /**
+     * Initial options defining the store when calling `defineStore()`.
+     */
+    options: DefineStoreOptionsInPlugin<Id, S, G, A>;
+}
+
+/**
+ * Plugin to extend every store.
+ * @deprecated use PiniaPlugin instead
+ */
+export declare type PiniaStorePlugin = PiniaPlugin;
+
+/**
+ * Vue 2 Plugin that must be installed for pinia to work. Note **you don't need
+ * this plugin if you are using Nuxt.js**. Use the `buildModule` instead:
+ * https://pinia.vuejs.org/ssr/nuxt.html.
+ *
+ * @example
+ * ```js
+ * import Vue from 'vue'
+ * import { PiniaVuePlugin, createPinia } from 'pinia'
+ *
+ * Vue.use(PiniaVuePlugin)
+ * const pinia = createPinia()
+ *
+ * new Vue({
+ *   el: '#app',
+ *   // ...
+ *   pinia,
+ * })
+ * ```
+ *
+ * @param _Vue - `Vue` imported from 'vue'.
+ */
+export declare const PiniaVuePlugin: Plugin_2;
+
+declare interface _SetActivePinia {
+    (pinia: Pinia): Pinia;
+    (pinia: undefined): undefined;
+    (pinia: Pinia | undefined): Pinia | undefined;
+}
+
+/**
+ * Sets or unsets the active pinia. Used in SSR and internally when calling
+ * actions and getters
+ *
+ * @param pinia - Pinia instance
+ */
+export declare const setActivePinia: _SetActivePinia;
+
+/**
+ * Changes the suffix added by `mapStores()`. Can be set to an empty string.
+ * Defaults to `"Store"`. Make sure to extend the MapStoresCustomization
+ * interface if you are using TypeScript.
+ *
+ * @param suffix - new suffix
+ */
+export declare function setMapStoreSuffix(suffix: MapStoresCustomization extends Record<'suffix', infer Suffix> ? Suffix : string): void;
+
+/**
+ * Tells Pinia to skip the hydration process of a given object. This is useful in setup stores (only) when you return a
+ * stateful object in the store but it isn't really state. e.g. returning a router instance in a setup store.
+ *
+ * @param obj - target object
+ * @returns obj
+ */
+export declare function skipHydrate<T = any>(obj: T): T;
+
+/**
+ * For internal use **only**.
+ */
+export declare type _Spread<A extends readonly any[]> = A extends [infer L, ...infer R] ? _StoreObject<L> & _Spread<R> : unknown;
+
+/**
+ * Generic state of a Store
+ */
+export declare type StateTree = Record<string | number | symbol, any>;
+
+/**
+ * Store type to build a store.
+ */
+export declare type Store<Id extends string = string, S extends StateTree = {}, G = {}, A = {}> = _StoreWithState<Id, S, G, A> & UnwrapRef<S> & _StoreWithGetters<G> & (_ActionsTree extends A ? {} : A) & PiniaCustomProperties<Id, S, G, A> & PiniaCustomStateProperties<S>;
+
+/**
+ * Extract the actions of a store type. Works with both a Setup Store or an
+ * Options Store.
+ */
+export declare type StoreActions<SS> = SS extends Store<string, StateTree, _GettersTree<StateTree>, infer A> ? A : _ExtractActionsFromSetupStore<SS>;
+
+/**
+ * Return type of `defineStore()`. Function that allows instantiating a store.
+ */
+export declare interface StoreDefinition<Id extends string = string, S extends StateTree = StateTree, G = _GettersTree<S>, A = _ActionsTree> {
+    /**
+     * Returns a store, creates it if necessary.
+     *
+     * @param pinia - Pinia instance to retrieve the store
+     * @param hot - dev only hot module replacement
+     */
+    (pinia?: Pinia | null | undefined, hot?: StoreGeneric): Store<Id, S, G, A>;
+    /**
+     * Id of the store. Used by map helpers.
+     */
+    $id: Id;
+    /* Excluded from this release type: _pinia */
+}
+
+/**
+ * Generic and type-unsafe version of Store. Doesn't fail on access with
+ * strings, making it much easier to write generic functions that do not care
+ * about the kind of store that is passed.
+ */
+export declare type StoreGeneric = Store<string, StateTree, _GettersTree<StateTree>, _ActionsTree>;
+
+/**
+ * Extract the getters of a store type. Works with both a Setup Store or an
+ * Options Store.
+ */
+export declare type StoreGetters<SS> = SS extends Store<string, StateTree, infer G, _ActionsTree> ? _StoreWithGetters<G> : _ExtractGettersFromSetupStore<SS>;
+
+/**
+ * For internal use **only**.
+ */
+export declare type _StoreObject<S> = S extends StoreDefinition<infer Ids, infer State, infer Getters, infer Actions> ? {
+    [Id in `${Ids}${MapStoresCustomization extends Record<'suffix', infer Suffix> ? Suffix : 'Store'}`]: () => Store<Id extends `${infer RealId}${MapStoresCustomization extends Record<'suffix', infer Suffix> ? Suffix : 'Store'}` ? RealId : string, State, Getters, Actions>;
+} : {};
+
+/**
+ * Argument of `store.$onAction()`
+ */
+export declare type StoreOnActionListener<Id extends string, S extends StateTree, G, A> = (context: StoreOnActionListenerContext<Id, S, G, {} extends A ? _ActionsTree : A>) => void;
+
+/**
+ * Context object passed to callbacks of `store.$onAction(context => {})`
+ * TODO: should have only the Id, the Store and Actions to generate the proper object
+ */
+export declare type StoreOnActionListenerContext<Id extends string, S extends StateTree, G, A> = _ActionsTree extends A ? _StoreOnActionListenerContext<StoreGeneric, string, _ActionsTree> : {
+    [Name in keyof A]: Name extends string ? _StoreOnActionListenerContext<Store<Id, S, G, A>, Name, A> : never;
+}[keyof A];
+
+/**
+ * Actual type for {@link StoreOnActionListenerContext}. Exists for refactoring
+ * purposes. For internal use only.
+ * For internal use **only**
+ */
+export declare interface _StoreOnActionListenerContext<Store, ActionName extends string, A> {
+    /**
+     * Name of the action
+     */
+    name: ActionName;
+    /**
+     * Store that is invoking the action
+     */
+    store: Store;
+    /**
+     * Parameters passed to the action
+     */
+    args: A extends Record<ActionName, _Method> ? Parameters<A[ActionName]> : unknown[];
+    /**
+     * Sets up a hook once the action is finished. It receives the return value
+     * of the action, if it's a Promise, it will be unwrapped.
+     */
+    after: (callback: A extends Record<ActionName, _Method> ? (resolvedReturn: _Awaited<ReturnType<A[ActionName]>>) => void : () => void) => void;
+    /**
+     * Sets up a hook if the action fails. Return `false` to catch the error and
+     * stop it from propagating.
+     */
+    onError: (callback: (error: unknown) => void) => void;
+}
+
+/**
+ * Properties of a store.
+ */
+export declare interface StoreProperties<Id extends string> {
+    /**
+     * Unique identifier of the store
+     */
+    $id: Id;
+    /* Excluded from this release type: _p */
+    /* Excluded from this release type: _getters */
+    /* Excluded from this release type: _isOptionsAPI */
+    /**
+     * Used by devtools plugin to retrieve properties added with plugins. Removed
+     * in production. Can be used by the user to add property keys of the store
+     * that should be displayed in devtools.
+     */
+    _customProperties: Set<string>;
+    /* Excluded from this release type: _hotUpdate */
+    /* Excluded from this release type: _hotUpdating */
+    /* Excluded from this release type: _hmrPayload */
+}
+
+/**
+ * Extract the state of a store type. Works with both a Setup Store or an
+ * Options Store. Note this unwraps refs.
+ */
+export declare type StoreState<SS> = SS extends Store<string, infer S, _GettersTree<StateTree>, _ActionsTree> ? UnwrapRef<S> : _ExtractStateFromSetupStore<SS>;
+
+/**
+ * Extracts the return type for `storeToRefs`.
+ * Will convert any `getters` into `ComputedRef`.
+ */
+declare type StoreToRefs<SS extends StoreGeneric> = ToRefs<StoreState<SS> & PiniaCustomStateProperties<StoreState<SS>>> & ToComputedRefs<StoreGetters<SS>>;
+
+/**
+ * Creates an object of references with all the state, getters, and plugin-added
+ * state properties of the store. Similar to `toRefs()` but specifically
+ * designed for Pinia stores so methods and non reactive properties are
+ * completely ignored.
+ *
+ * @param store - store to extract the refs from
+ */
+export declare function storeToRefs<SS extends StoreGeneric>(store: SS): StoreToRefs<SS>;
+
+/**
+ * Store augmented for actions. For internal usage only.
+ * For internal use **only**
+ */
+export declare type _StoreWithActions<A> = {
+    [k in keyof A]: A[k] extends (...args: infer P) => infer R ? (...args: P) => R : never;
+};
+
+/**
+ * Store augmented with getters. For internal usage only.
+ * For internal use **only**
+ */
+export declare type _StoreWithGetters<G> = {
+    readonly [k in keyof G]: G[k] extends (...args: any[]) => infer R ? R : UnwrapRef<G[k]>;
+};
+
+/**
+ * Base store with state and functions. Should not be used directly.
+ */
+export declare interface _StoreWithState<Id extends string, S extends StateTree, G, A> extends StoreProperties<Id> {
+    /**
+     * State of the Store. Setting it will internally call `$patch()` to update the state.
+     */
+    $state: UnwrapRef<S> & PiniaCustomStateProperties<S>;
+    /**
+     * Applies a state patch to current state. Allows passing nested values
+     *
+     * @param partialState - patch to apply to the state
+     */
+    $patch(partialState: _DeepPartial<UnwrapRef<S>>): void;
+    /**
+     * Group multiple changes into one function. Useful when mutating objects like
+     * Sets or arrays and applying an object patch isn't practical, e.g. appending
+     * to an array. The function passed to `$patch()` **must be synchronous**.
+     *
+     * @param stateMutator - function that mutates `state`, cannot be asynchronous
+     */
+    $patch<F extends (state: UnwrapRef<S>) => any>(stateMutator: ReturnType<F> extends Promise<any> ? never : F): void;
+    /**
+     * Resets the store to its initial state by building a new state object.
+     * TODO: make this options only
+     */
+    $reset(): void;
+    /**
+     * Setups a callback to be called whenever the state changes. It also returns a function to remove the callback. Note
+     * that when calling `store.$subscribe()` inside of a component, it will be automatically cleaned up when the
+     * component gets unmounted unless `detached` is set to true.
+     *
+     * @param callback - callback passed to the watcher
+     * @param options - `watch` options + `detached` to detach the subscription from the context (usually a component)
+     * this is called from. Note that the `flush` option does not affect calls to `store.$patch()`.
+     * @returns function that removes the watcher
+     */
+    $subscribe(callback: SubscriptionCallback<S>, options?: {
+        detached?: boolean;
+    } & WatchOptions): () => void;
+    /**
+     * Setups a callback to be called every time an action is about to get
+     * invoked. The callback receives an object with all the relevant information
+     * of the invoked action:
+     * - `store`: the store it is invoked on
+     * - `name`: The name of the action
+     * - `args`: The parameters passed to the action
+     *
+     * On top of these, it receives two functions that allow setting up a callback
+     * once the action finishes or when it fails.
+     *
+     * It also returns a function to remove the callback. Note than when calling
+     * `store.$onAction()` inside of a component, it will be automatically cleaned
+     * up when the component gets unmounted unless `detached` is set to true.
+     *
+     * @example
+     *
+     *```js
+     *store.$onAction(({ after, onError }) => {
+     *  // Here you could share variables between all of the hooks as well as
+     *  // setting up watchers and clean them up
+     *  after((resolvedValue) => {
+     *    // can be used to cleanup side effects
+     * .  // `resolvedValue` is the value returned by the action, if it's a
+     * .  // Promise, it will be the resolved value instead of the Promise
+     *  })
+     *  onError((error) => {
+     *    // can be used to pass up errors
+     *  })
+     *})
+     *```
+     *
+     * @param callback - callback called before every action
+     * @param detached - detach the subscription from the context this is called from
+     * @returns function that removes the watcher
+     */
+    $onAction(callback: StoreOnActionListener<Id, S, G, A>, detached?: boolean): () => void;
+    /**
+     * Stops the associated effect scope of the store and remove it from the store
+     * registry. Plugins can override this method to cleanup any added effects.
+     * e.g. devtools plugin stops displaying disposed stores from devtools.
+     * Note this doesn't delete the state of the store, you have to do it manually with
+     * `delete pinia.state.value[store.$id]` if you want to. If you don't and the
+     * store is used again, it will reuse the previous state.
+     */
+    $dispose(): void;
+    /* Excluded from this release type: _r */
+}
+
+/**
+ * Callback of a subscription
+ */
+export declare type SubscriptionCallback<S> = (
+/**
+ * Object with information relative to the store mutation that triggered the
+ * subscription.
+ */
+mutation: SubscriptionCallbackMutation<S>, 
+/**
+ * State of the store when the subscription is triggered. Same as
+ * `store.$state`.
+ */
+state: UnwrapRef<S>) => void;
+
+/**
+ * Context object passed to a subscription callback.
+ */
+export declare type SubscriptionCallbackMutation<S> = SubscriptionCallbackMutationDirect | SubscriptionCallbackMutationPatchObject<S> | SubscriptionCallbackMutationPatchFunction;
+
+/**
+ * Base type for the context passed to a subscription callback. Internal type.
+ */
+export declare interface _SubscriptionCallbackMutationBase {
+    /**
+     * Type of the mutation.
+     */
+    type: MutationType;
+    /**
+     * `id` of the store doing the mutation.
+     */
+    storeId: string;
+    /**
+     * 🔴 DEV ONLY, DO NOT use for production code. Different mutation calls. Comes from
+     * https://vuejs.org/guide/extras/reactivity-in-depth.html#reactivity-debugging and allows to track mutations in
+     * devtools and plugins **during development only**.
+     */
+    events?: DebuggerEvent[] | DebuggerEvent;
+}
+
+/**
+ * Context passed to a subscription callback when directly mutating the state of
+ * a store with `store.someState = newValue` or `store.$state.someState =
+ * newValue`.
+ */
+export declare interface SubscriptionCallbackMutationDirect extends _SubscriptionCallbackMutationBase {
+    type: MutationType.direct;
+    events: DebuggerEvent;
+}
+
+/**
+ * Context passed to a subscription callback when `store.$patch()` is called
+ * with a function.
+ */
+export declare interface SubscriptionCallbackMutationPatchFunction extends _SubscriptionCallbackMutationBase {
+    type: MutationType.patchFunction;
+    events: DebuggerEvent[];
+}
+
+/**
+ * Context passed to a subscription callback when `store.$patch()` is called
+ * with an object.
+ */
+export declare interface SubscriptionCallbackMutationPatchObject<S> extends _SubscriptionCallbackMutationBase {
+    type: MutationType.patchObject;
+    events: DebuggerEvent[];
+    /**
+     * Object passed to `store.$patch()`.
+     */
+    payload: _DeepPartial<S>;
+}
+
+declare type ToComputedRefs<T> = {
+    [K in keyof T]: ToRef<T[K]> extends Ref<infer U> ? ComputedRef<U> : ToRef<T[K]>;
+};
+
+/**
+ * Type that enables refactoring through IDE.
+ * For internal use **only**
+ */
+export declare type _UnwrapAll<SS> = {
+    [K in keyof SS]: UnwrapRef<SS[K]>;
+};
+
+export { }
+
+// Extensions of Vue types to be appended manually
+// https://github.com/microsoft/rushstack/issues/2090
+// https://github.com/microsoft/rushstack/issues/1709
+
+// @ts-ignore: works on Vue 2, fails in Vue 3
+declare module 'vue/types/vue' {
+  interface Vue {
+    /**
+     * Currently installed pinia instance.
+     */
+    $pinia: Pinia
+
+    /**
+     * Cache of stores instantiated by the current instance. Used by map
+     * helpers. Used internally by Pinia.
+     *
+     * @internal
+     */
+    _pStores?: Record<string, Store>
+  }
+}
+
+// @ts-ignore: works on Vue 2, fails in Vue 3
+declare module 'vue/types/options' {
+  interface ComponentOptions<V> {
+    /**
+     * Pinia instance to install in your application. Should be passed to the
+     * root Vue.
+     */
+    pinia?: Pinia
+  }
+}
+
+// TODO: figure out why it cannot be 'vue'
+// @ts-ignore: works on Vue 3, fails in Vue 2
+declare module '@vue/runtime-core' {
+  export interface ComponentCustomProperties {
+    /**
+     * Access to the application's Pinia
+     */
+    $pinia: Pinia
+
+    /**
+     * Cache of stores instantiated by the current instance. Used by devtools to
+     * list currently used stores. Used internally by Pinia.
+     *
+     * @internal
+     */
+    _pStores?: Record<string, StoreGeneric>
+  }
+}

node_modules/pinia/dist/pinia.prod.cjs

@@ -0,0 +1,808 @@
+/*!
+ * pinia v2.1.6
+ * (c) 2023 Eduardo San Martin Morote
+ * @license MIT
+ */
+'use strict';
+
+var vueDemi = require('vue-demi');
+
+/**
+ * setActivePinia must be called to handle SSR at the top of functions like
+ * `fetch`, `setup`, `serverPrefetch` and others
+ */
+let activePinia;
+/**
+ * Sets or unsets the active pinia. Used in SSR and internally when calling
+ * actions and getters
+ *
+ * @param pinia - Pinia instance
+ */
+// @ts-expect-error: cannot constrain the type of the return
+const setActivePinia = (pinia) => (activePinia = pinia);
+/**
+ * Get the currently active pinia if there is any.
+ */
+const getActivePinia = () => (vueDemi.hasInjectionContext() && vueDemi.inject(piniaSymbol)) || activePinia;
+const piniaSymbol = (/* istanbul ignore next */ Symbol());
+
+function isPlainObject(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+o) {
+    return (o &&
+        typeof o === 'object' &&
+        Object.prototype.toString.call(o) === '[object Object]' &&
+        typeof o.toJSON !== 'function');
+}
+// type DeepReadonly<T> = { readonly [P in keyof T]: DeepReadonly<T[P]> }
+// TODO: can we change these to numbers?
+/**
+ * Possible types for SubscriptionCallback
+ */
+exports.MutationType = void 0;
+(function (MutationType) {
+    /**
+     * Direct mutation of the state:
+     *
+     * - `store.name = 'new name'`
+     * - `store.$state.name = 'new name'`
+     * - `store.list.push('new item')`
+     */
+    MutationType["direct"] = "direct";
+    /**
+     * Mutated the state with `$patch` and an object
+     *
+     * - `store.$patch({ name: 'newName' })`
+     */
+    MutationType["patchObject"] = "patch object";
+    /**
+     * Mutated the state with `$patch` and a function
+     *
+     * - `store.$patch(state => state.name = 'newName')`
+     */
+    MutationType["patchFunction"] = "patch function";
+    // maybe reset? for $state = {} and $reset
+})(exports.MutationType || (exports.MutationType = {}));
+
+const IS_CLIENT = typeof window !== 'undefined';
+
+/**
+ * Creates a Pinia instance to be used by the application
+ */
+function createPinia() {
+    const scope = vueDemi.effectScope(true);
+    // NOTE: here we could check the window object for a state and directly set it
+    // if there is anything like it with Vue 3 SSR
+    const state = scope.run(() => vueDemi.ref({}));
+    let _p = [];
+    // plugins added before calling app.use(pinia)
+    let toBeInstalled = [];
+    const pinia = vueDemi.markRaw({
+        install(app) {
+            // this allows calling useStore() outside of a component setup after
+            // installing pinia's plugin
+            setActivePinia(pinia);
+            if (!vueDemi.isVue2) {
+                pinia._a = app;
+                app.provide(piniaSymbol, pinia);
+                app.config.globalProperties.$pinia = pinia;
+                toBeInstalled.forEach((plugin) => _p.push(plugin));
+                toBeInstalled = [];
+            }
+        },
+        use(plugin) {
+            if (!this._a && !vueDemi.isVue2) {
+                toBeInstalled.push(plugin);
+            }
+            else {
+                _p.push(plugin);
+            }
+            return this;
+        },
+        _p,
+        // it's actually undefined here
+        // @ts-expect-error
+        _a: null,
+        _e: scope,
+        _s: new Map(),
+        state,
+    });
+    return pinia;
+}
+
+/**
+ * Creates an _accept_ function to pass to `import.meta.hot` in Vite applications.
+ *
+ * @example
+ * ```js
+ * const useUser = defineStore(...)
+ * if (import.meta.hot) {
+ *   import.meta.hot.accept(acceptHMRUpdate(useUser, import.meta.hot))
+ * }
+ * ```
+ *
+ * @param initialUseStore - return of the defineStore to hot update
+ * @param hot - `import.meta.hot`
+ */
+function acceptHMRUpdate(initialUseStore, hot) {
+    // strip as much as possible from iife.prod
+    {
+        return () => { };
+    }
+}
+
+const noop = () => { };
+function addSubscription(subscriptions, callback, detached, onCleanup = noop) {
+    subscriptions.push(callback);
+    const removeSubscription = () => {
+        const idx = subscriptions.indexOf(callback);
+        if (idx > -1) {
+            subscriptions.splice(idx, 1);
+            onCleanup();
+        }
+    };
+    if (!detached && vueDemi.getCurrentScope()) {
+        vueDemi.onScopeDispose(removeSubscription);
+    }
+    return removeSubscription;
+}
+function triggerSubscriptions(subscriptions, ...args) {
+    subscriptions.slice().forEach((callback) => {
+        callback(...args);
+    });
+}
+
+const fallbackRunWithContext = (fn) => fn();
+function mergeReactiveObjects(target, patchToApply) {
+    // Handle Map instances
+    if (target instanceof Map && patchToApply instanceof Map) {
+        patchToApply.forEach((value, key) => target.set(key, value));
+    }
+    // Handle Set instances
+    if (target instanceof Set && patchToApply instanceof Set) {
+        patchToApply.forEach(target.add, target);
+    }
+    // no need to go through symbols because they cannot be serialized anyway
+    for (const key in patchToApply) {
+        if (!patchToApply.hasOwnProperty(key))
+            continue;
+        const subPatch = patchToApply[key];
+        const targetValue = target[key];
+        if (isPlainObject(targetValue) &&
+            isPlainObject(subPatch) &&
+            target.hasOwnProperty(key) &&
+            !vueDemi.isRef(subPatch) &&
+            !vueDemi.isReactive(subPatch)) {
+            // NOTE: here I wanted to warn about inconsistent types but it's not possible because in setup stores one might
+            // start the value of a property as a certain type e.g. a Map, and then for some reason, during SSR, change that
+            // to `undefined`. When trying to hydrate, we want to override the Map with `undefined`.
+            target[key] = mergeReactiveObjects(targetValue, subPatch);
+        }
+        else {
+            // @ts-expect-error: subPatch is a valid value
+            target[key] = subPatch;
+        }
+    }
+    return target;
+}
+const skipHydrateSymbol = /* istanbul ignore next */ Symbol();
+const skipHydrateMap = /*#__PURE__*/ new WeakMap();
+/**
+ * Tells Pinia to skip the hydration process of a given object. This is useful in setup stores (only) when you return a
+ * stateful object in the store but it isn't really state. e.g. returning a router instance in a setup store.
+ *
+ * @param obj - target object
+ * @returns obj
+ */
+function skipHydrate(obj) {
+    return vueDemi.isVue2
+        ? // in @vue/composition-api, the refs are sealed so defineProperty doesn't work...
+            /* istanbul ignore next */ skipHydrateMap.set(obj, 1) && obj
+        : Object.defineProperty(obj, skipHydrateSymbol, {});
+}
+/**
+ * Returns whether a value should be hydrated
+ *
+ * @param obj - target variable
+ * @returns true if `obj` should be hydrated
+ */
+function shouldHydrate(obj) {
+    return vueDemi.isVue2
+        ? /* istanbul ignore next */ !skipHydrateMap.has(obj)
+        : !isPlainObject(obj) || !obj.hasOwnProperty(skipHydrateSymbol);
+}
+const { assign } = Object;
+function isComputed(o) {
+    return !!(vueDemi.isRef(o) && o.effect);
+}
+function createOptionsStore(id, options, pinia, hot) {
+    const { state, actions, getters } = options;
+    const initialState = pinia.state.value[id];
+    let store;
+    function setup() {
+        if (!initialState && (!false )) {
+            /* istanbul ignore if */
+            if (vueDemi.isVue2) {
+                vueDemi.set(pinia.state.value, id, state ? state() : {});
+            }
+            else {
+                pinia.state.value[id] = state ? state() : {};
+            }
+        }
+        // avoid creating a state in pinia.state.value
+        const localState = vueDemi.toRefs(pinia.state.value[id]);
+        return assign(localState, actions, Object.keys(getters || {}).reduce((computedGetters, name) => {
+            computedGetters[name] = vueDemi.markRaw(vueDemi.computed(() => {
+                setActivePinia(pinia);
+                // it was created just before
+                const store = pinia._s.get(id);
+                // allow cross using stores
+                /* istanbul ignore next */
+                if (vueDemi.isVue2 && !store._r)
+                    return;
+                // @ts-expect-error
+                // return getters![name].call(context, context)
+                // TODO: avoid reading the getter while assigning with a global variable
+                return getters[name].call(store, store);
+            }));
+            return computedGetters;
+        }, {}));
+    }
+    store = createSetupStore(id, setup, options, pinia, hot, true);
+    return store;
+}
+function createSetupStore($id, setup, options = {}, pinia, hot, isOptionsStore) {
+    let scope;
+    const optionsForPlugin = assign({ actions: {} }, options);
+    // watcher options for $subscribe
+    const $subscribeOptions = {
+        deep: true,
+        // flush: 'post',
+    };
+    // internal state
+    let isListening; // set to true at the end
+    let isSyncListening; // set to true at the end
+    let subscriptions = [];
+    let actionSubscriptions = [];
+    let debuggerEvents;
+    const initialState = pinia.state.value[$id];
+    // avoid setting the state for option stores if it is set
+    // by the setup
+    if (!isOptionsStore && !initialState && (!false )) {
+        /* istanbul ignore if */
+        if (vueDemi.isVue2) {
+            vueDemi.set(pinia.state.value, $id, {});
+        }
+        else {
+            pinia.state.value[$id] = {};
+        }
+    }
+    vueDemi.ref({});
+    // avoid triggering too many listeners
+    // https://github.com/vuejs/pinia/issues/1129
+    let activeListener;
+    function $patch(partialStateOrMutator) {
+        let subscriptionMutation;
+        isListening = isSyncListening = false;
+        if (typeof partialStateOrMutator === 'function') {
+            partialStateOrMutator(pinia.state.value[$id]);
+            subscriptionMutation = {
+                type: exports.MutationType.patchFunction,
+                storeId: $id,
+                events: debuggerEvents,
+            };
+        }
+        else {
+            mergeReactiveObjects(pinia.state.value[$id], partialStateOrMutator);
+            subscriptionMutation = {
+                type: exports.MutationType.patchObject,
+                payload: partialStateOrMutator,
+                storeId: $id,
+                events: debuggerEvents,
+            };
+        }
+        const myListenerId = (activeListener = Symbol());
+        vueDemi.nextTick().then(() => {
+            if (activeListener === myListenerId) {
+                isListening = true;
+            }
+        });
+        isSyncListening = true;
+        // because we paused the watcher, we need to manually call the subscriptions
+        triggerSubscriptions(subscriptions, subscriptionMutation, pinia.state.value[$id]);
+    }
+    const $reset = isOptionsStore
+        ? function $reset() {
+            const { state } = options;
+            const newState = state ? state() : {};
+            // we use a patch to group all changes into one single subscription
+            this.$patch(($state) => {
+                assign($state, newState);
+            });
+        }
+        : /* istanbul ignore next */
+            noop;
+    function $dispose() {
+        scope.stop();
+        subscriptions = [];
+        actionSubscriptions = [];
+        pinia._s.delete($id);
+    }
+    /**
+     * Wraps an action to handle subscriptions.
+     *
+     * @param name - name of the action
+     * @param action - action to wrap
+     * @returns a wrapped action to handle subscriptions
+     */
+    function wrapAction(name, action) {
+        return function () {
+            setActivePinia(pinia);
+            const args = Array.from(arguments);
+            const afterCallbackList = [];
+            const onErrorCallbackList = [];
+            function after(callback) {
+                afterCallbackList.push(callback);
+            }
+            function onError(callback) {
+                onErrorCallbackList.push(callback);
+            }
+            // @ts-expect-error
+            triggerSubscriptions(actionSubscriptions, {
+                args,
+                name,
+                store,
+                after,
+                onError,
+            });
+            let ret;
+            try {
+                ret = action.apply(this && this.$id === $id ? this : store, args);
+                // handle sync errors
+            }
+            catch (error) {
+                triggerSubscriptions(onErrorCallbackList, error);
+                throw error;
+            }
+            if (ret instanceof Promise) {
+                return ret
+                    .then((value) => {
+                    triggerSubscriptions(afterCallbackList, value);
+                    return value;
+                })
+                    .catch((error) => {
+                    triggerSubscriptions(onErrorCallbackList, error);
+                    return Promise.reject(error);
+                });
+            }
+            // trigger after callbacks
+            triggerSubscriptions(afterCallbackList, ret);
+            return ret;
+        };
+    }
+    const partialStore = {
+        _p: pinia,
+        // _s: scope,
+        $id,
+        $onAction: addSubscription.bind(null, actionSubscriptions),
+        $patch,
+        $reset,
+        $subscribe(callback, options = {}) {
+            const removeSubscription = addSubscription(subscriptions, callback, options.detached, () => stopWatcher());
+            const stopWatcher = scope.run(() => vueDemi.watch(() => pinia.state.value[$id], (state) => {
+                if (options.flush === 'sync' ? isSyncListening : isListening) {
+                    callback({
+                        storeId: $id,
+                        type: exports.MutationType.direct,
+                        events: debuggerEvents,
+                    }, state);
+                }
+            }, assign({}, $subscribeOptions, options)));
+            return removeSubscription;
+        },
+        $dispose,
+    };
+    /* istanbul ignore if */
+    if (vueDemi.isVue2) {
+        // start as non ready
+        partialStore._r = false;
+    }
+    const store = vueDemi.reactive(partialStore);
+    // store the partial store now so the setup of stores can instantiate each other before they are finished without
+    // creating infinite loops.
+    pinia._s.set($id, store);
+    const runWithContext = (pinia._a && pinia._a.runWithContext) || fallbackRunWithContext;
+    // TODO: idea create skipSerialize that marks properties as non serializable and they are skipped
+    const setupStore = pinia._e.run(() => {
+        scope = vueDemi.effectScope();
+        return runWithContext(() => scope.run(setup));
+    });
+    // overwrite existing actions to support $onAction
+    for (const key in setupStore) {
+        const prop = setupStore[key];
+        if ((vueDemi.isRef(prop) && !isComputed(prop)) || vueDemi.isReactive(prop)) {
+            // mark it as a piece of state to be serialized
+            if (!isOptionsStore) {
+                // in setup stores we must hydrate the state and sync pinia state tree with the refs the user just created
+                if (initialState && shouldHydrate(prop)) {
+                    if (vueDemi.isRef(prop)) {
+                        prop.value = initialState[key];
+                    }
+                    else {
+                        // probably a reactive object, lets recursively assign
+                        // @ts-expect-error: prop is unknown
+                        mergeReactiveObjects(prop, initialState[key]);
+                    }
+                }
+                // transfer the ref to the pinia state to keep everything in sync
+                /* istanbul ignore if */
+                if (vueDemi.isVue2) {
+                    vueDemi.set(pinia.state.value[$id], key, prop);
+                }
+                else {
+                    pinia.state.value[$id][key] = prop;
+                }
+            }
+            // action
+        }
+        else if (typeof prop === 'function') {
+            // @ts-expect-error: we are overriding the function we avoid wrapping if
+            const actionValue = wrapAction(key, prop);
+            // this a hot module replacement store because the hotUpdate method needs
+            // to do it with the right context
+            /* istanbul ignore if */
+            if (vueDemi.isVue2) {
+                vueDemi.set(setupStore, key, actionValue);
+            }
+            else {
+                // @ts-expect-error
+                setupStore[key] = actionValue;
+            }
+            // list actions so they can be used in plugins
+            // @ts-expect-error
+            optionsForPlugin.actions[key] = prop;
+        }
+        else ;
+    }
+    // add the state, getters, and action properties
+    /* istanbul ignore if */
+    if (vueDemi.isVue2) {
+        Object.keys(setupStore).forEach((key) => {
+            vueDemi.set(store, key, setupStore[key]);
+        });
+    }
+    else {
+        assign(store, setupStore);
+        // allows retrieving reactive objects with `storeToRefs()`. Must be called after assigning to the reactive object.
+        // Make `storeToRefs()` work with `reactive()` #799
+        assign(vueDemi.toRaw(store), setupStore);
+    }
+    // use this instead of a computed with setter to be able to create it anywhere
+    // without linking the computed lifespan to wherever the store is first
+    // created.
+    Object.defineProperty(store, '$state', {
+        get: () => (pinia.state.value[$id]),
+        set: (state) => {
+            $patch(($state) => {
+                assign($state, state);
+            });
+        },
+    });
+    /* istanbul ignore if */
+    if (vueDemi.isVue2) {
+        // mark the store as ready before plugins
+        store._r = true;
+    }
+    // apply all plugins
+    pinia._p.forEach((extender) => {
+        /* istanbul ignore else */
+        {
+            assign(store, scope.run(() => extender({
+                store,
+                app: pinia._a,
+                pinia,
+                options: optionsForPlugin,
+            })));
+        }
+    });
+    // only apply hydrate to option stores with an initial state in pinia
+    if (initialState &&
+        isOptionsStore &&
+        options.hydrate) {
+        options.hydrate(store.$state, initialState);
+    }
+    isListening = true;
+    isSyncListening = true;
+    return store;
+}
+function defineStore(
+// TODO: add proper types from above
+idOrOptions, setup, setupOptions) {
+    let id;
+    let options;
+    const isSetupStore = typeof setup === 'function';
+    if (typeof idOrOptions === 'string') {
+        id = idOrOptions;
+        // the option store setup will contain the actual options in this case
+        options = isSetupStore ? setupOptions : setup;
+    }
+    else {
+        options = idOrOptions;
+        id = idOrOptions.id;
+    }
+    function useStore(pinia, hot) {
+        const hasContext = vueDemi.hasInjectionContext();
+        pinia =
+            // in test mode, ignore the argument provided as we can always retrieve a
+            // pinia instance with getActivePinia()
+            ((process.env.NODE_ENV === 'test') && activePinia && activePinia._testing ? null : pinia) ||
+                (hasContext ? vueDemi.inject(piniaSymbol, null) : null);
+        if (pinia)
+            setActivePinia(pinia);
+        pinia = activePinia;
+        if (!pinia._s.has(id)) {
+            // creating the store registers it in `pinia._s`
+            if (isSetupStore) {
+                createSetupStore(id, setup, options, pinia);
+            }
+            else {
+                createOptionsStore(id, options, pinia);
+            }
+        }
+        const store = pinia._s.get(id);
+        // StoreGeneric cannot be casted towards Store
+        return store;
+    }
+    useStore.$id = id;
+    return useStore;
+}
+
+let mapStoreSuffix = 'Store';
+/**
+ * Changes the suffix added by `mapStores()`. Can be set to an empty string.
+ * Defaults to `"Store"`. Make sure to extend the MapStoresCustomization
+ * interface if you are using TypeScript.
+ *
+ * @param suffix - new suffix
+ */
+function setMapStoreSuffix(suffix // could be 'Store' but that would be annoying for JS
+) {
+    mapStoreSuffix = suffix;
+}
+/**
+ * Allows using stores without the composition API (`setup()`) by generating an
+ * object to be spread in the `computed` field of a component. It accepts a list
+ * of store definitions.
+ *
+ * @example
+ * ```js
+ * export default {
+ *   computed: {
+ *     // other computed properties
+ *     ...mapStores(useUserStore, useCartStore)
+ *   },
+ *
+ *   created() {
+ *     this.userStore // store with id "user"
+ *     this.cartStore // store with id "cart"
+ *   }
+ * }
+ * ```
+ *
+ * @param stores - list of stores to map to an object
+ */
+function mapStores(...stores) {
+    return stores.reduce((reduced, useStore) => {
+        // @ts-expect-error: $id is added by defineStore
+        reduced[useStore.$id + mapStoreSuffix] = function () {
+            return useStore(this.$pinia);
+        };
+        return reduced;
+    }, {});
+}
+/**
+ * Allows using state and getters from one store without using the composition
+ * API (`setup()`) by generating an object to be spread in the `computed` field
+ * of a component.
+ *
+ * @param useStore - store to map from
+ * @param keysOrMapper - array or object
+ */
+function mapState(useStore, keysOrMapper) {
+    return Array.isArray(keysOrMapper)
+        ? keysOrMapper.reduce((reduced, key) => {
+            reduced[key] = function () {
+                return useStore(this.$pinia)[key];
+            };
+            return reduced;
+        }, {})
+        : Object.keys(keysOrMapper).reduce((reduced, key) => {
+            // @ts-expect-error
+            reduced[key] = function () {
+                const store = useStore(this.$pinia);
+                const storeKey = keysOrMapper[key];
+                // for some reason TS is unable to infer the type of storeKey to be a
+                // function
+                return typeof storeKey === 'function'
+                    ? storeKey.call(this, store)
+                    : store[storeKey];
+            };
+            return reduced;
+        }, {});
+}
+/**
+ * Alias for `mapState()`. You should use `mapState()` instead.
+ * @deprecated use `mapState()` instead.
+ */
+const mapGetters = mapState;
+/**
+ * Allows directly using actions from your store without using the composition
+ * API (`setup()`) by generating an object to be spread in the `methods` field
+ * of a component.
+ *
+ * @param useStore - store to map from
+ * @param keysOrMapper - array or object
+ */
+function mapActions(useStore, keysOrMapper) {
+    return Array.isArray(keysOrMapper)
+        ? keysOrMapper.reduce((reduced, key) => {
+            // @ts-expect-error
+            reduced[key] = function (...args) {
+                return useStore(this.$pinia)[key](...args);
+            };
+            return reduced;
+        }, {})
+        : Object.keys(keysOrMapper).reduce((reduced, key) => {
+            // @ts-expect-error
+            reduced[key] = function (...args) {
+                return useStore(this.$pinia)[keysOrMapper[key]](...args);
+            };
+            return reduced;
+        }, {});
+}
+/**
+ * Allows using state and getters from one store without using the composition
+ * API (`setup()`) by generating an object to be spread in the `computed` field
+ * of a component.
+ *
+ * @param useStore - store to map from
+ * @param keysOrMapper - array or object
+ */
+function mapWritableState(useStore, keysOrMapper) {
+    return Array.isArray(keysOrMapper)
+        ? keysOrMapper.reduce((reduced, key) => {
+            // @ts-ignore
+            reduced[key] = {
+                get() {
+                    return useStore(this.$pinia)[key];
+                },
+                set(value) {
+                    // it's easier to type it here as any
+                    return (useStore(this.$pinia)[key] = value);
+                },
+            };
+            return reduced;
+        }, {})
+        : Object.keys(keysOrMapper).reduce((reduced, key) => {
+            // @ts-ignore
+            reduced[key] = {
+                get() {
+                    return useStore(this.$pinia)[keysOrMapper[key]];
+                },
+                set(value) {
+                    // it's easier to type it here as any
+                    return (useStore(this.$pinia)[keysOrMapper[key]] = value);
+                },
+            };
+            return reduced;
+        }, {});
+}
+
+/**
+ * Creates an object of references with all the state, getters, and plugin-added
+ * state properties of the store. Similar to `toRefs()` but specifically
+ * designed for Pinia stores so methods and non reactive properties are
+ * completely ignored.
+ *
+ * @param store - store to extract the refs from
+ */
+function storeToRefs(store) {
+    // See https://github.com/vuejs/pinia/issues/852
+    // It's easier to just use toRefs() even if it includes more stuff
+    if (vueDemi.isVue2) {
+        // @ts-expect-error: toRefs include methods and others
+        return vueDemi.toRefs(store);
+    }
+    else {
+        store = vueDemi.toRaw(store);
+        const refs = {};
+        for (const key in store) {
+            const value = store[key];
+            if (vueDemi.isRef(value) || vueDemi.isReactive(value)) {
+                // @ts-expect-error: the key is state or getter
+                refs[key] =
+                    // ---
+                    vueDemi.toRef(store, key);
+            }
+        }
+        return refs;
+    }
+}
+
+/**
+ * Vue 2 Plugin that must be installed for pinia to work. Note **you don't need
+ * this plugin if you are using Nuxt.js**. Use the `buildModule` instead:
+ * https://pinia.vuejs.org/ssr/nuxt.html.
+ *
+ * @example
+ * ```js
+ * import Vue from 'vue'
+ * import { PiniaVuePlugin, createPinia } from 'pinia'
+ *
+ * Vue.use(PiniaVuePlugin)
+ * const pinia = createPinia()
+ *
+ * new Vue({
+ *   el: '#app',
+ *   // ...
+ *   pinia,
+ * })
+ * ```
+ *
+ * @param _Vue - `Vue` imported from 'vue'.
+ */
+const PiniaVuePlugin = function (_Vue) {
+    // Equivalent of
+    // app.config.globalProperties.$pinia = pinia
+    _Vue.mixin({
+        beforeCreate() {
+            const options = this.$options;
+            if (options.pinia) {
+                const pinia = options.pinia;
+                // HACK: taken from provide(): https://github.com/vuejs/composition-api/blob/main/src/apis/inject.ts#L31
+                /* istanbul ignore else */
+                if (!this._provided) {
+                    const provideCache = {};
+                    Object.defineProperty(this, '_provided', {
+                        get: () => provideCache,
+                        set: (v) => Object.assign(provideCache, v),
+                    });
+                }
+                this._provided[piniaSymbol] = pinia;
+                // propagate the pinia instance in an SSR friendly way
+                // avoid adding it to nuxt twice
+                /* istanbul ignore else */
+                if (!this.$pinia) {
+                    this.$pinia = pinia;
+                }
+                pinia._a = this;
+                if (IS_CLIENT) {
+                    // this allows calling useStore() outside of a component setup after
+                    // installing pinia's plugin
+                    setActivePinia(pinia);
+                }
+            }
+            else if (!this.$pinia && options.parent && options.parent.$pinia) {
+                this.$pinia = options.parent.$pinia;
+            }
+        },
+        destroyed() {
+            delete this._pStores;
+        },
+    });
+};
+
+exports.PiniaVuePlugin = PiniaVuePlugin;
+exports.acceptHMRUpdate = acceptHMRUpdate;
+exports.createPinia = createPinia;
+exports.defineStore = defineStore;
+exports.getActivePinia = getActivePinia;
+exports.mapActions = mapActions;
+exports.mapGetters = mapGetters;
+exports.mapState = mapState;
+exports.mapStores = mapStores;
+exports.mapWritableState = mapWritableState;
+exports.setActivePinia = setActivePinia;
+exports.setMapStoreSuffix = setMapStoreSuffix;
+exports.skipHydrate = skipHydrate;
+exports.storeToRefs = storeToRefs;