import { State } from "./state.js";

//#region src/context.d.ts
type Accept<T extends State = State> = T | State.Type<T> | Record<string | number, T | State.Type<T>>;
type Expect<T extends State = State> = (state: T, downstream: boolean) => (() => void) | void;
declare namespace Context {
  export { Accept, Expect };
}
declare class Context {
  static get root(): Context;
  /** Get the context for a State. Adapters may override to provide framework context. */
  static get(state?: State): Context;
  id: string;
  parent?: Context;
  scope: Set<Context>;
  consume: Map<State.Extends<State>, Set<[Expect<State>, boolean | undefined]> | null>;
  provide: Map<State.Extends<State>, Set<[State, boolean]> | null>;
  protected inputs: Record<string | number, State | State.Extends>;
  private cleanup;
  constructor(arg?: Context | Accept);
  private traverse;
  private register;
  /** Find specified type upstream. Throws if not found. */
  get<T extends State>(Type: State.Extends<T>, required?: true): T;
  /** Find specified type upstream. Returns undefined if not found. */
  get<T extends State>(Type: State.Extends<T>, required?: boolean): T | undefined;
  /** Subscribe to a type becoming available in context. */
  get<T extends State>(Type: State.Extends<T>, callback: Expect<T>, downstream?: boolean): () => void;
  /** Lookup excluding a specific instance (used by State.prototype.get for upstream-of-self semantics). */
  get<T extends State>(Type: State.Extends<T>, arg: boolean | Expect<T> | undefined, downstream: boolean | undefined, skip: State): T | undefined | (() => void);
  /**
   * Register one or more States to this context.
   *
   * Context will add or remove States as needed to keep with provided input.
   *
   * @param inputs State, State class, or map of States / State classes to register.
   * @param forEach Optional callback to run for each State registered. Receives
   *   whether this context created the State - and so will destroy it - as
   *   opposed to it having been provided already active. May return a callback
   *   to run before that entry is dropped.
   */
  set<T extends State>(inputs: Accept<T>, forEach?: (state: T, owned: boolean) => (() => void) | void): this;
  add(I: State, explicit?: boolean): () => void;
  /**
   * Create a child context, optionally registering one or more States to it.
   *
   * @param inputs State, State class, or map of States / State classes to register.
   */
  push(inputs?: Accept): Context;
  /**
   * Remove all States from this context.
   *
   * Will also run any cleanup callbacks registered when States were added.
   */
  pop(): void;
}
/**
 * Add `value` to the context `state` was added to. A context-less `state` holds
 * it instead - every context adding `state` later adds its held children too.
 */
declare function join(state: State, value: State): () => void;
//#endregion
export { Context, join };
//# sourceMappingURL=context.d.ts.map