//#region src/lib/constrain.d.ts
type Constrain<T, S$1> = T & S$1;
//#endregion
//#region src/lib/maybePromise.d.ts
type MaybePromise<T> = T | Promise<T>;
//#endregion
//#region src/lib/typeHelpers.d.ts
type Object_ = Record<string | number | symbol, any>;
type Array_ = readonly any[];
type StringToNumber<T> = T extends `${infer K extends number}` ? K : never;
type ArrayToStringPath<T> = T extends readonly [] ? "" : T extends readonly [infer First extends string | number, ...infer Rest] ? First extends `${string}.${string}` ? never : Rest extends readonly [] ? `${First}` : `${First}.${ArrayToStringPath<Rest>}` : T extends readonly KeyType[] ? string : never;
type StringToArrayPath<T> = T extends "" ? readonly [] : T extends `${infer First}.${infer Rest}` ? readonly [First, ...StringToArrayPath<Rest>] : readonly [T];
type OptionalPropertyOf<T> = Exclude<{ [K in keyof T]: string extends K ? K : number extends K ? K : symbol extends K ? K : T extends Record<K, T[K]> ? never : K }[keyof T], undefined>;
type OptionalProperties<T> = Pick<T, OptionalPropertyOf<T>>;
type IsAny<T> = 0 extends 1 & T ? true : false;
type IsNever<T> = [T] extends [never] ? true : false;
//#endregion
//#region src/lib/path.d.ts
type KeyType = string | number | symbol;
type AnyPath = string | readonly KeyType[];
type GetKeys<T extends Object_ | Array_> = T extends Array_ ? T extends readonly [] ? never : "0" extends keyof T ? StringToNumber<keyof T> : number : keyof T;
type _PathAsArray<T, Optional, MaxDepth, Depth extends 1[]> = (Optional extends false ? readonly [] : never) | (true extends IsAny<T> ? readonly KeyType[] : T extends never ? never : T extends Object_ ? Depth["length"] extends MaxDepth ? readonly string[] : T extends Map<infer K extends KeyType, infer V> ? readonly [K] | readonly [K, ..._PathAsArray<V, Optional, MaxDepth, [...Depth, 1]>] : T extends Set<any> ? readonly [number] : { [K in GetKeys<T>]: (Optional extends true ? K extends OptionalPropertyOf<T> ? readonly [K] : never : readonly [K]) | readonly [K, ..._PathAsArray<T[K], Optional, MaxDepth, [...Depth, 1]>] }[GetKeys<T>] : never);
type PathAsArray<T, Optional extends boolean = false, MaxDepth extends number = 5> = _PathAsArray<T, Optional, MaxDepth, []>;
type PathAsString<T, Optional extends boolean = false, MaxDepth extends number = 5> = ArrayToStringPath<PathAsArray<T, Optional, MaxDepth>>;
type Path<T, Optional extends boolean = false, MaxDepth extends number = 5> = PathAsString<T, Optional, MaxDepth> | PathAsArray<T, Optional, MaxDepth>;
type Value<T, P$1> = P$1 extends readonly [] ? T : true extends IsAny<T> | IsAny<P$1> ? any : true extends IsNever<T> | IsNever<P$1> ? never : P$1 extends string ? Value<T, StringToArrayPath<P$1>> : P$1 extends readonly [infer First extends KeyType, ...infer Rest extends readonly KeyType[]] ? T extends Map<any, infer V> | Set<infer V> ? Value<V, Rest> | undefined : T extends Array_ ? any[] extends T ? Value<T[First & keyof T], Rest> | undefined : Value<T[First & keyof T], Rest> : T extends Object_ ? Record<any, any> extends T ? Value<T[First], Rest> | undefined : Value<T[First], Rest> : never : never;
type _WildcardPathAsArray<T, MaxDepth, Depth extends 1[]> = [] | (0 extends 1 & T ? KeyType[] : T extends never ? never : T extends Object_ ? Depth["length"] extends MaxDepth ? string[] : T extends Map<infer K extends KeyType, infer V> ? ["*"] | [K] | [K, ..._WildcardPathAsArray<V, MaxDepth, [...Depth, 1]>] : T extends Set<any> ? ["*"] | [number] : Record<string, any> extends T ? ["*"] | ["*", ..._WildcardPathAsArray<T[string], MaxDepth, [...Depth, 1]>] : { [K in GetKeys<T>]: ["*"] | ["*", ..._WildcardPathAsArray<T[T extends readonly any[] ? number : keyof T], MaxDepth, [...Depth, 1]>] | [K] | [K, ..._WildcardPathAsArray<T[K], MaxDepth, [...Depth, 1]>] }[GetKeys<T>] : never);
type WildcardPathAsArray<T, MaxDepth extends number = 5> = _WildcardPathAsArray<T, MaxDepth, []>;
type WildcardPathAsString<T, MaxDepth extends number = 5> = ArrayToStringPath<_WildcardPathAsArray<T, MaxDepth, []>>;
type WildcardPath<T, MaxDepth extends number = 5> = WildcardPathAsString<T, MaxDepth> | WildcardPathAsArray<T, MaxDepth>;
type WildcardValue<T, P$1> = true extends IsAny<T> | IsAny<P$1> ? any : true extends IsNever<T> | IsNever<P$1> ? never : P$1 extends string ? WildcardValue<T, StringToArrayPath<P$1>> : P$1 extends readonly [infer First extends KeyType, ...infer Rest extends KeyType[]] ? T extends Map<any, infer V> | Set<infer V> ? WildcardValue<V, Rest> | (First extends "*" ? never : undefined) : T extends Array_ ? First extends "*" ? WildcardValue<T[number], Rest> : any[] extends T ? WildcardValue<T[First & keyof T], Rest> | undefined : First extends keyof T ? WildcardValue<T[First], Rest> : undefined : T extends Object_ ? First extends "*" ? WildcardValue<T[keyof T], Rest> : Record<any, any> extends T ? WildcardValue<T[First], Rest> | undefined : WildcardValue<T[First], Rest> : never : T;
type Join<A extends string | number, B extends string | number> = A extends "" ? B : B extends "" ? A : `${A}.${B}`;
type _SettablePathAsArray<T, MaxDepth, Depth extends 1[]> = readonly [] | (true extends IsAny<T> ? readonly KeyType[] : undefined extends T ? T extends Map<any, any> | Set<any> ? never : T extends Object_ ? { [K in GetKeys<T>]: Partial<T> extends Omit<T, K> ? readonly [K] | readonly [K, ..._SettablePathAsArray<T[K], MaxDepth, [...Depth, 1]>] : readonly [] }[GetKeys<T>] : never : T extends never ? never : T extends Object_ ? Depth["length"] extends MaxDepth ? readonly string[] : T extends Map<infer K extends KeyType, infer V> ? readonly [K] | readonly [K, ..._SettablePathAsArray<V, MaxDepth, [...Depth, 1]>] : T extends Set<any> ? readonly [number] : { [K in GetKeys<T>]: readonly [K] | readonly [K, ..._SettablePathAsArray<T[K], MaxDepth, [...Depth, 1]>] }[GetKeys<T>] : never);
type SettablePathAsArray<T, MaxDepth extends number = 5> = _SettablePathAsArray<T, MaxDepth, []>;
type SettablePathAsString<T, MaxDepth extends number = 5> = ArrayToStringPath<SettablePathAsArray<T, MaxDepth>>;
type SettablePath<T, MaxDepth extends number = 5> = SettablePathAsString<T, MaxDepth> | SettablePathAsArray<T, MaxDepth>;
type SettableValue<T, P$1> = P$1 extends readonly [] ? T : true extends IsAny<T> | IsAny<P$1> ? any : true extends IsNever<T> | IsNever<P$1> ? never : P$1 extends string ? SettableValue<T, StringToArrayPath<P$1>> : P$1 extends readonly [infer First extends KeyType, ...infer Rest extends readonly KeyType[]] ? T extends Map<any, infer V> | Set<infer V> ? SettableValue<V, Rest> : T extends Array_ ? SettableValue<T[First & keyof T], Rest> : T extends Object_ ? SettableValue<T[First], Rest> : never : never;
//#endregion
//#region src/lib/debounce.d.ts
type DebounceOptions = Duration | {
  wait: Duration;
  maxWait?: Duration;
  waitOnRunNow?: boolean;
};
//#endregion
//#region src/core/commonTypes.d.ts
interface Listener<T = void, TThis = unknown> {
  (this: TThis, value: T, previouseValue?: T): void;
}
interface Selector<T, S$1> {
  (value: T): S$1;
}
interface Effect<T> {
  (this: T, context: T): void | Cancel;
}
interface SubscribeOptions {
  /** If set, this listener does not activate the store.
  * @default false
  */
  passive?: boolean;
  /** Whether to execute the callback immediately with the current store value.
  * @default true
  */
  runNow?: boolean;
  /** If set, throttle how often the callback can be executed.
  * The values says how much time needs to pass between to calls.
  * @example
  * subscribe(callback, { throttle: { seconds: 10 } }); // Will execute immediately and then at least 10 seconds havbe to pass. If the store changed during those 10 seconds, the callback will be executed again.
  */
  throttle?: Duration;
  /** If set, callback execution is delayed. */
  debounce?: DebounceOptions;
  /** Provide a custom equality function. By default a strict equals (===) will be used.
  */
  equals?: (a: any, b: any) => boolean;
  /** An optional AbortSignal that can be used to unsubscribe the listener automatically. */
  signal?: AbortSignal;
}
interface EffectOptions {
  /** If provided, delay tearing down effects when the last subscriber is removed. This is useful if a short gap in subscriber coverage is supposed to be ignored. E.g. when switching pages, the old page might unsubscribe, while the new page subscribes immediately after. */
  retain?: Duration;
  /** An optional AbortSignal that can be used to cancel the effect. */
  signal?: AbortSignal;
}
interface Cancel {
  (): void;
}
interface DisposableCancel {
  (): void;
  [Symbol.dispose](): void;
}
interface DurationObject {
  milliseconds?: number;
  seconds?: number;
  minutes?: number;
  hours?: number;
  days?: number;
  months?: number;
  years?: number;
}
type Duration = number | string | DurationObject;
type UpdateFrom<Value$1, From extends any[]> = Value$1 | ((...args: From) => Value$1);
type Update<Value$1> = UpdateFrom<Value$1, [Value$1]>;
interface UpdateFunction<Value$1> {
  (update: Update<Value$1>): void;
}
interface AsyncUpdateFunction<Value$1> {
  (update: UpdateFrom<MaybePromise<Value$1>, [Value$1]>): void;
}
interface StoreLike<T> {
  get(): T;
  subscribe(listener: (value: T) => void, options?: {
    runNow?: boolean;
  }): Cancel;
  invalidate(recursive?: boolean): void;
}
interface Use {
  <T>(store: StoreLike<T>): T;
}
interface BaseConnectionActions<T> {
  set: UpdateFunction<T>;
}
interface AsyncConnectionActions<T> extends BaseConnectionActions<T> {
  updateValue: AsyncUpdateFunction<T>;
  updateError: (error: unknown) => void;
  updateIsConnected: (isConnected: boolean) => void;
  close: () => void;
}
type ConnectionActions<T> = BaseConnectionActions<T> & (T extends Promise<infer S> ? AsyncConnectionActions<S> : {});
interface Connection<T> {
  (actions: ConnectionActions<T>): Cancel;
}
interface CalculationActions<T> {
  signal: AbortSignal;
  use: Use;
  connect(connection: Connection<T>): Promise<void>;
}
//#endregion
//#region src/lib/calculatedValue.d.ts
interface CalculatedValue<T> {
  value: T;
  check: () => void;
  stop(): void;
  invalidateDependencies(recursive?: boolean): void;
}
//#endregion
//#region src/lib/promiseWithCancel.d.ts
declare class PromiseWithCancel<T> extends Promise<T> {
  private abortController;
  constructor(executor: (resolve: (value: T) => void, reject: (error: unknown) => void, signal: AbortSignal) => void);
  cancel(reason?: any): void;
}
//#endregion
//#region src/lib/standardMethods.d.ts
type Function_ = (...args: any) => any;
declare const arrayMethods: { [P in "splice" | "push" | "pop" | "shift" | "unshift" | "reverse" | "sort"]: <T extends Array<any>>(this: Store<T>, ...args: T[P] extends Function_ ? Parameters<T[P]> : never) => T[P] extends Function_ ? ReturnType<T[P]> : never };
declare const recordMethods: {
  delete<T extends Record<any, any>, K$1 extends OptionalPropertyOf<T>>(this: Store<T>, key: K$1): void;
  clear<T extends Record<any, any>>(this: OptionalProperties<T> extends T ? Store<T> : never): void;
};
declare const mapMethods: {
  delete<K$1, V$1>(this: Store<Map<K$1, V$1>>, key: K$1): boolean;
  clear<K$1, V$1>(this: Store<Map<K$1, V$1>>): void;
};
declare const setMethods: {
  add<T>(this: Store<Set<T>>, value: T): void;
  delete<T>(this: Store<Set<T>>, value: T): void;
  clear<T>(this: Store<Set<T>>): void;
};
//#endregion
//#region src/core/store.d.ts
type StoreMethods = Record<string, (...args: any[]) => any>;
type BoundStoreMethods<T, Methods extends StoreMethods> = Methods & ThisType<Store<T> & Methods>;
interface StoreOptions<T> {
  retain?: Duration;
  equals?: SubscribeOptions["equals"];
  effect?: Effect<Store<T>> | {
    effect: Effect<Store<T>>;
    retain?: Duration;
  };
  cacheValue?: boolean;
}
interface StoreOptionsWithMethods<T, Methods extends StoreMethods> extends StoreOptions<T> {
  methods?: Methods & ThisType<Store<T> & Methods & StandardMethods<T>>;
}
type Calculate<T> = (helpers: CalculationActions<T>) => T;
type StandardMethods<T> = T extends Map<any, any> ? typeof mapMethods : T extends Set<any> ? typeof setMethods : T extends Array<any> ? typeof arrayMethods : T extends Record<any, any> ? typeof recordMethods : Record<string, never>;
type StoreWithMethods<T, Methods extends StoreMethods> = Store<T> & Omit<BoundStoreMethods<T, Methods>, keyof Store<T>> & StandardMethods<T>;
interface OnceOptions {
  signal?: AbortSignal;
  timeout?: Duration;
}
declare class Store<T> {
  readonly getter: T | Calculate<T>;
  readonly options: StoreOptions<T>;
  readonly derivedFrom?: {
    store: Store<any>;
    selectors: (Selector<any, any> | AnyPath)[];
    updater: (state: any) => void;
  } | undefined;
  private static hooks?;
  static addHook(hook: (store: Store<any>) => void): DisposableCancel;
  version?: string;
  protected calculatedValue?: CalculatedValue<T>;
  protected defaultValue?: CalculatedValue<T>;
  protected listeners: Map<Listener, boolean>;
  protected effects: Map<Effect<Store<T>>, {
    handle?: Cancel;
    retain?: number;
    timeout?: ReturnType<typeof setTimeout>;
  }>;
  protected notifyId: {};
  constructor(getter: T | Calculate<T>, options?: StoreOptions<T>, derivedFrom?: {
    store: Store<any>;
    selectors: (Selector<any, any> | AnyPath)[];
    updater: (state: any) => void;
  } | undefined);
  get(): T;
  set(update: Update<T>): void;
  set<const P$1>(path: Constrain<P$1, Path<T>>, update: Update<Value<T, P$1>>): void;
  invalidate(recursive?: boolean): void;
  subscribe(listener: Listener<T, {
    cancel: Cancel;
  }>, options?: SubscribeOptions): DisposableCancel;
  once<S$1 extends T>(condition: (value: T) => value is S$1, options?: OnceOptions): PromiseWithCancel<S$1>;
  once(condition: (value: T) => boolean, options?: OnceOptions): PromiseWithCancel<T>;
  once(options?: OnceOptions): PromiseWithCancel<Exclude<T, undefined>>;
  map<S$1>(selector: Selector<T, S$1>, updater?: (value: S$1) => Update<T>): Store<S$1>;
  map<const P$1>(selector: Constrain<P$1, SettablePath<T>>): Store<Value<T, P$1>>;
  /** Add an effect that will be executed when the store becomes active, which means when it has at least one subscriber.
  * @param effect
  * If there is already a subscriber, the effect will be executed immediately.
  * Otherweise it will be executed as soon as the first subscription is created.
  * Every time all subscriptions are removed and the first is created again, the effect will be executed again.
  * @param retain
  * If provided, delay tearing down effects when the last subscriber is removed. This is useful if a short gap in subscriber coverage is supposed to be ignored. E.g. when switching pages, the old page might unsubscribe, while the new page subscribes immediately after.
  * @returns
  * The effect can return a teardown callback, which will be executed when the last subscription is removed and potentially the ratain time has passed.
  */
  addEffect(effect: Effect<Store<T>>, {
    retain,
    signal
  }?: EffectOptions): DisposableCancel;
  /** Return whether the store is currently active, which means whether it has at least one subscriber. */
  isActive(): boolean;
  protected onSubscribe(): void;
  protected onUnsubscribe(): void;
  protected notify(): void;
}
declare function create<T>(calculate: Calculate<T>, options?: StoreOptions<T>): Store<T>;
declare function create<T, Methods extends StoreMethods = {}>(initialState: T, options?: StoreOptionsWithMethods<T, Methods>): StoreWithMethods<T, Methods>;
declare const createStore: typeof create & {
  defaultOptions: StoreOptions<any>;
};
//#endregion
export { GetKeys as A, Value as B, Selector as C, UpdateFunction as D, UpdateFrom as E, PathAsString as F, MaybePromise as G, WildcardPathAsString as H, SettablePath as I, Constrain as K, SettablePathAsArray as L, KeyType as M, Path as N, Use as O, PathAsArray as P, SettablePathAsString as R, Listener as S, Update as T, WildcardValue as U, WildcardPath as V, Object_ as W, Connection as _, StoreOptions as a, Duration as b, arrayMethods as c, setMethods as d, AsyncConnectionActions as f, Cancel as g, CalculationActions as h, StoreMethods as i, Join as j, AnyPath as k, mapMethods as l, BaseConnectionActions as m, Calculate as n, StoreOptionsWithMethods as o, AsyncUpdateFunction as p, Store as r, createStore as s, BoundStoreMethods as t, recordMethods as u, ConnectionActions as v, SubscribeOptions as w, Effect as x, DisposableCancel as y, SettableValue as z };
//# sourceMappingURL=store-21GsOOLS.d.cts.map