import { Ref, proxy, ref, snapshot, subscribe } from "@destyler/store";
//#region src/deep-merge.d.ts
export declare function deepMerge<T extends Record<string, any>>(source: T, ...objects: (Partial<T> | undefined | null)[]): T;
export declare function deepMerge<T extends Record<string, any>, U extends Record<string, any>[]>(source: T, ...objects: (U[number] | undefined | null)[]): T & UnionToIntersection$1<U[number]>;
type UnionToIntersection$1<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
//#endregion
//#region src/machine.d.ts
declare const stoppingKey: unique symbol;
declare const startingKey: unique symbol;
declare const lifecycleVersionKey: unique symbol;
declare const runVersionKey: unique symbol;
declare const exitingStateKey: unique symbol;
declare const stopPhaseKey: unique symbol;
declare const pendingStopsKey: unique symbol;
export declare class Machine<TContext extends Dict, TState extends StateSchema, TEvent extends EventObject = AnyEventObject> {
  status: MachineStatus;
  readonly state: XState<TContext, TState, TEvent>;
  private [stoppingKey];
  private [startingKey];
  private [stopPhaseKey];
  private [pendingStopsKey];
  private [lifecycleVersionKey];
  private [runVersionKey];
  private [exitingStateKey];
  initialState: StateInfo<TContext, TState, TEvent> | undefined;
  initialContext: TContext;
  id: string;
  type: MachineType;
  private activityEvents;
  private delayedEvents;
  private stateListeners;
  private doneListeners;
  private contextWatchers;
  private removeStateListener;
  private parent?;
  private children;
  private guardMap;
  private actionMap;
  private delayMap;
  private activityMap;
  private sync;
  options: MachineOptions<TContext, TState, TEvent>;
  config: MachineConfig<TContext, TState, TEvent>;
  constructor(config: MachineConfig<TContext, TState, TEvent>, options?: MachineOptions<TContext, TState, TEvent>);
  private get stateSnapshot();
  getState(): XState<TContext, TState, TEvent>;
  get contextSnapshot(): TContext;
  _created: () => void;
  start: (init?: StateInit<TContext, TState>) => this;
  private setupContextWatchers;
  stop: () => this | undefined;
  private stopStateListeners;
  private stopContextWatchers;
  private stopDelayedEvents;
  private stopActivities;
  /**
   * Function to send event to spawned child machine or actor
   */
  sendChild: (evt: Event<AnyEventObject>, to: string | ((ctx: TContext) => string)) => void;
  /**
   * Function to stop a running child machine or actor
   */
  stopChild: (id: string) => void;
  removeChild: (id: string) => void;
  private stopChildren;
  private setParent;
  spawn: <TContext_1 extends Dict, TState_1 extends StateSchema, TEvent_1 extends EventObject = AnyEventObject>(src: MachineSrc<TContext_1, TState_1, TEvent_1>, id?: string) => Machine<TContext_1, TState_1, TEvent_1>;
  private stopActivity;
  private addActivityCleanup;
  private setState;
  /**
   * To used within side effects for React or Vue to update context
   */
  setContext: (context: Partial<Writable<TContext>> | undefined) => void;
  setOptions: (options: Partial<MachineOptions<TContext, TState, TEvent>>) => void;
  private getStateNode;
  private getNextStateInfo;
  private getAfterActions;
  /**
   * All `after` events leverage `setTimeout` and `clearTimeout`,
   * we invoke the `clearTimeout` on exit and `setTimeout` on entry.
   *
   * To achieve this, we split the `after` definition into `entry` and `exit`
   *  functions and append them to the state's `entry` and `exit` actions
   */
  private getDelayedEventActions;
  /**
   * A reference to the instance methods of the machine.
   * Useful when spawning child machines and managing the communication between them.
   */
  private get self();
  private get meta();
  private get guardMeta();
  /**
   * Function to executes defined actions. It can accept actions as string
   * (referencing `options.actions`) or actual functions.
   */
  private executeActions;
  /**
   * Function to execute running activities and registers
   * their cleanup function internally (to be called later on when we exit the state)
   */
  private executeActivities;
  /**
   * Normalizes the `every` definition to transition. `every` can be:
   * - An array of possible actions to run (we need to pick the first match based on guard)
   * - An object of intervals and actions
   */
  private createEveryActivities;
  private setEvent;
  private performExitEffects;
  private performEntryEffects;
  private performTransitionEffects;
  /**
   * Performs all the requires side-effects or reactions when
   * we move from state A => state B.
   *
   * The Effect order:
   * Exit actions (current state) => Transition actions  => Go to state => Entry actions (next state)
   */
  private performStateChangeEffects;
  private determineTransition;
  /**
   * Function to send event to parent machine from spawned child
   */
  sendParent: (evt: Event<AnyEventObject>) => void;
  private log;
  /**
   * Function to send an event to current machine
   */
  send: (evt: Event<TEvent>) => void;
  transition: (state: TState["value"] | StateInfo<TContext, TState, TEvent> | null, evt: Event<TEvent>) => StateNode<TContext, TState, TEvent> | undefined;
  subscribe: (listener: StateListener<TContext, TState, TEvent>) => () => void;
  onDone: (listener: StateListener<TContext, TState, TEvent>) => this;
  onTransition: (listener: StateListener<TContext, TState, TEvent>) => this;
  get [Symbol.toStringTag](): string;
  getHydrationState(): StateInit<TContext, TState>;
}
export type MachineSrc<TContext extends Dict, TState extends StateSchema, TEvent extends EventObject = AnyEventObject> = Machine<TContext, TState, TEvent> | (() => Machine<TContext, TState, TEvent>);
export type AnyMachine = Machine<Dict, StateSchema, AnyEventObject>;
export declare function createMachine<TContext extends Dict, TState extends StateSchema = StateSchema, TEvent extends EventObject = AnyEventObject>(config: MachineConfig<TContext, TState, TEvent>, options?: MachineOptions<TContext, TState, TEvent>): Machine<TContext, TState, TEvent>;
export declare function isMachine(value: any): value is AnyMachine;
//#endregion
//#region src/type.d.ts
type Dict<T = any> = Record<string, T>;
type MaybeArray<T> = T | T[];
type VoidFunction = () => void;
type IfEquals<X, Y, A, B> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? A : B;
type WritableKey<T> = { [P in keyof T]: IfEquals<{ [Q in P]: T[P]; }, { -readonly [Q in P]: T[P]; }, P, never>; }[keyof T];
type Writable<T> = Pick<T, WritableKey<T>>;
type Computed<T> = Omit<T, WritableKey<T>>;
/**
 * Context types
 */
/** Combined context type with readonly computed properties */
type Context<V, C> = V & Readonly<C>;
/** Computed context properties definition */
type TComputedContext<T> = { [K in keyof Computed<T>]: (ctx: T) => T[K]; };
/** User-provided context (only writable properties) */
type UserContext<TContext> = Partial<Writable<TContext>>;
/** Context change listener callback */
type ContextListener<TContext extends Dict> = (context: TContext) => void;
/**
 * Event types - can be either a string or object
 */
/** Base event object interface */
interface EventObject {
  type: string;
}
/** Event can be a type string or event object */
type Event<TEvent extends EventObject = EventObject> = TEvent['type'] | TEvent;
/** Event object with additional properties */
interface AnyEventObject extends EventObject {
  [key: string]: any;
}
/** Function to send events to the machine */
type XSend<TEvent extends EventObject = AnyEventObject> = (event: Event<TEvent>) => void;
/** Event listener callback */
type EventListener<TEvent extends EventObject = AnyEventObject> = (event: TEvent) => void;
/** Extract specific event type from union */
type ExtractEvent<TEvent extends EventObject, K> = K extends TEvent['type'] ? Extract<TEvent, {
  type: K;
}> : EventObject;
/**
 * Expression types - actions and activities are expressions
 */
type Expression<TContext extends Dict, TEvent extends EventObject, TReturn> = (context: TContext, event: TEvent) => TReturn;
/** Meta information passed to expressions */
interface Meta<TContext extends Dict, TState extends StateSchema, TEvent extends EventObject> {
  state: XState<TContext, TState>;
  guards: Dict;
  send: XSend<TEvent>;
  self: XSelf<TContext, TState, TEvent>;
  initialContext: TContext;
  initialState: string;
  getState: () => XState<TContext, TState, TEvent>;
  getAction: (key: string) => ExpressionWithMeta<TContext, TState, TEvent, void>;
  getGuard: (key: string) => GuardExpression<TContext, TState, TEvent>;
}
/** Expression with access to meta information */
type ExpressionWithMeta<TContext extends Dict, TState extends StateSchema, TEvent extends EventObject, TReturn> = (context: TContext, event: TEvent, meta: Meta<TContext, TState, TEvent>) => TReturn;
/**
 * Action types
 */
/** Single action - can be string reference or function */
type Action<TContext extends Dict, TState extends StateSchema, TEvent extends EventObject> = string | ExpressionWithMeta<TContext, TState, TEvent, void>;
/** Multiple actions - can include conditional actions */
type Actions<TContext extends Dict, TState extends StateSchema, TEvent extends EventObject> = ChooseHelper<TContext, TState, TEvent> | MaybeArray<Action<TContext, TState, TEvent>>;
/** Pure actions without conditional logic */
type PureActions<TContext extends Dict, TState extends StateSchema, TEvent extends EventObject> = MaybeArray<Action<TContext, TState, TEvent>>;
/** Map of action names to implementations */
interface ActionMap<TContext extends Dict, TState extends StateSchema, TEvent extends EventObject> {
  [action: string]: ExpressionWithMeta<TContext, TState, TEvent, void>;
}
/**
 * Activity types
 */
/** Activity - long-running process with cleanup */
type Activity<TContext extends Dict, TState extends StateSchema, TEvent extends EventObject> = string | ExpressionWithMeta<TContext, TState, TEvent, VoidFunction | void | undefined>;
/** Multiple activities */
type Activities<TContext extends Dict, TState extends StateSchema, TEvent extends EventObject> = MaybeArray<Activity<TContext, TState, TEvent>>;
/** Map of activity names to implementations */
interface ActivityMap<TContext extends Dict, TState extends StateSchema, TEvent extends EventObject> {
  [activity: string]: ExpressionWithMeta<TContext, TState, TEvent, VoidFunction | void | undefined>;
}
/**
 * Transition types
 */
/** Transition definition with target, actions, and guards */
interface TransitionDefinition<TContext extends Dict, TState extends StateSchema, TEvent extends EventObject> {
  /** Target state to transition to */
  target?: TState['value'] | undefined;
  /** Actions to execute during transition */
  actions?: Actions<TContext, TState, TEvent> | undefined;
  /** Guard condition for the transition */
  guard?: Guard<TContext, TState, TEvent> | undefined;
  /** Whether this is an internal transition */
  internal?: boolean | undefined;
}
/** Delay expression function */
type DelayExpression<TContext extends Dict, TEvent extends EventObject> = Expression<TContext, TEvent, number>;
/** Delay specification - string, number, or expression */
type Delay<TContext extends Dict, TEvent extends EventObject> = string | number | DelayExpression<TContext, TEvent>;
/** Map of delay names to implementations */
interface DelayMap<TContext extends Dict, TEvent extends EventObject> {
  [delay: string]: number | DelayExpression<TContext, TEvent>;
}
/** Transition with delay specification for 'after' and 'every' */
type DelayedTransition<TContext extends Dict, TState extends StateSchema, TEvent extends EventObject> = TransitionDefinition<TContext, TState, TEvent> & {
  /** The time to delay the event, in milliseconds */
  delay?: Delay<TContext, TEvent> | undefined;
};
/** Collection of delayed transitions */
type DelayedTransitions<TContext extends Dict, TState extends StateSchema, TEvent extends EventObject> = Record<string | number, TState['value'] | MaybeArray<TransitionDefinition<TContext, TState, TEvent>>> | Array<DelayedTransition<TContext, TState, TEvent>>;
/** Transition can be a string (target) or full definition object */
type Transition<TContext extends Dict, TState extends StateSchema, TEvent extends EventObject> = TState['value'] | TransitionDefinition<TContext, TState, TEvent>;
/** Multiple transition possibilities with guards */
type Transitions<TContext extends Dict, TState extends StateSchema, TEvent extends EventObject> = Transition<TContext, TState, TEvent> | Array<TransitionDefinition<TContext, TState, TEvent>>;
/** Map of event types to their transitions */
type TransitionDefinitionMap<TContext extends Dict, TState extends StateSchema, TEvent extends EventObject> = { [K in TEvent['type']]?: TState['value'] | MaybeArray<TransitionDefinition<TContext, TState, ExtractEvent<TEvent, K>>> | undefined; };
/**
 * State node definition
 */
/** Configuration for a single state node */
interface StateNode<TContext extends Dict, TState extends StateSchema, TEvent extends EventObject> {
  /** The type of this state node */
  type?: 'final' | undefined;
  /** The tags for the state node */
  tags?: MaybeArray<TState['tags'] extends string ? TState['tags'] : string> | undefined;
  /** Activities to start on entry and stop on exit */
  activities?: Activities<TContext, TState, TEvent> | undefined;
  /** Event to transition mappings */
  on?: TransitionDefinitionMap<TContext, TState, TEvent> | undefined;
  /** Actions to execute on state entry */
  entry?: Actions<TContext, TState, TEvent> | undefined;
  /** Actions to execute on state exit */
  exit?: Actions<TContext, TState, TEvent> | undefined;
  /** Meta data associated with this state node */
  meta?: string | Dict | undefined;
  /** Delayed transitions using setTimeout */
  after?: DelayedTransitions<TContext, TState, TEvent> | undefined;
  /** Interval-based actions using setInterval */
  every?: Record<string | number, Actions<TContext, TState, TEvent>> | Array<{
    delay?: number | string | Expression<TContext, TEvent, number>;
    actions: Actions<TContext, TState, TEvent>;
    guard?: Guard<TContext, TState, TEvent>;
  }> | undefined;
}
/**
 * Guard types
 */
/** Meta information available to guard functions */
interface GuardMeta<TContext extends Dict, TState extends StateSchema, TEvent extends EventObject> {
  state: Pick<XState<TContext, TState, TEvent>, 'matches'>;
}
/** Guard expression function */
type GuardExpression<TContext extends Dict, TState extends StateSchema, TEvent extends EventObject, TReturn = boolean> = (context: TContext, event: TEvent, guardMeta: GuardMeta<TContext, TState, TEvent>) => TReturn;
/** Guard helper for complex guard logic */
interface GuardHelper<TContext extends Dict, TState extends StateSchema, TEvent extends EventObject> {
  predicate: (guards: Dict) => GuardExpression<TContext, TState, TEvent>;
}
/** Helper for conditional action selection */
interface ChooseHelper<TContext extends Dict, TState extends StateSchema, TEvent extends EventObject> {
  predicate: (guards: Dict) => GuardExpression<TContext, TState, TEvent, PureActions<TContext, TState, TEvent> | undefined>;
}
/** Guard can be string reference, function, or helper */
type Guard<TContext extends Dict, TState extends StateSchema, TEvent extends EventObject> = string | GuardExpression<TContext, TState, TEvent> | GuardHelper<TContext, TState, TEvent>;
/** Map of guard names to implementations */
interface GuardMap<TContext extends Dict, TState extends StateSchema, TEvent extends EventObject> {
  [guard: string]: GuardExpression<TContext, TState, TEvent>;
}
/**
 * State types
 */
/** Schema defining state structure */
interface StateSchema {
  value: string;
  tags?: string | undefined;
}
/** State initialization object */
interface StateInitObject<TContext, TState extends StateSchema> {
  context?: TContext | undefined;
  value: TState['value'] | null;
  tags?: TState['tags'][] | undefined;
}
/** State initialization type */
type StateInit<TContext, TState extends StateSchema> = StateInitObject<TContext, TState>;
/** State change listener callback */
type StateListener<TContext extends Dict, TState extends StateSchema, TEvent extends EventObject = EventObject> = (state: XState<TContext, TState, TEvent>) => void;
/** Information about state transition */
interface StateInfo<TContext extends Dict, TState extends StateSchema, TEvent extends EventObject> {
  /** Whether the state was re-entered */
  reenter: boolean;
  /** Whether the state changed */
  changed: boolean;
  /** The transition definition that caused this state */
  transition: TransitionDefinition<TContext, TState, TEvent> | undefined;
  /** The state node configuration */
  stateNode: StateNode<TContext, TState, TEvent> | undefined;
  /** The target state value */
  target: TState['value'];
}
/**
 * Machine configuration types
 */
/** Main machine configuration */
interface MachineConfig<TContext extends Dict, TState extends StateSchema, TEvent extends EventObject> {
  /** Actions to run after machine instantiation */
  created?: Actions<TContext, TState, TEvent> | undefined;
  /** Actions to run when machine starts */
  entry?: Actions<TContext, TState, TEvent> | undefined;
  /** Actions to run when machine stops */
  exit?: Actions<TContext, TState, TEvent> | undefined;
  /** Root level activities */
  activities?: Activities<TContext, TState, TEvent> | undefined;
  /** Unique machine identifier */
  id?: string | undefined;
  /** Extended state data */
  context?: Writable<TContext> | undefined;
  /** Context change watchers */
  watch?: { [K in keyof TContext]?: Actions<TContext, TState, TEvent>; } | undefined;
  /** Computed properties */
  computed?: Partial<TComputedContext<TContext>> | undefined;
  /** Initial state */
  initial?: TState['value'] | undefined;
  /** State node configurations */
  states?: Partial<Record<TState['value'], StateNode<TContext, TState, TEvent>>> | undefined;
  /** Root level event transitions */
  on?: TransitionDefinitionMap<TContext, TState, TEvent> | undefined;
}
/** Current state representation */
interface XState<TContext extends Dict, TState extends StateSchema = StateSchema, TEvent extends EventObject = AnyEventObject> {
  /** Current state value */
  value: TState['value'] | null;
  /** Previous state value */
  previousValue: TState['value'] | null;
  /** Current event */
  event: TEvent;
  /** Previous event */
  previousEvent: TEvent;
  /** Current context */
  context: TContext;
  /** Whether machine is in final state */
  done: boolean;
  /** Check if event can be sent */
  can: (event: string) => boolean;
  /** Check if state matches given values */
  matches: (...value: TState['value'][]) => boolean;
  /** Check if state has given tag */
  hasTag: (value: TState['tags']) => boolean;
  /** Events that can be sent from current state */
  nextEvents: string[];
  /** Whether state has changed */
  changed: boolean;
  /** Current state tags */
  tags: TState['tags'][];
}
/**
 * Machine options types
 */
/** Options for machine configuration */
interface MachineOptions<TContext extends Dict, TState extends StateSchema, TEvent extends EventObject> {
  /** Enable debug logging */
  debug?: boolean | undefined;
  /** Guard implementations */
  guards?: GuardMap<TContext, TState, TEvent> | undefined;
  /** Action implementations */
  actions?: ActionMap<TContext, TState, TEvent> | undefined;
  /** Delay implementations */
  delays?: DelayMap<TContext, TEvent> | undefined;
  /** Activity implementations */
  activities?: ActivityMap<TContext, TState, TEvent> | undefined;
  /** Synchronous execution mode */
  sync?: boolean | undefined;
  /** Custom comparison functions for context properties */
  compareFns?: { [K in keyof TContext]?: CompareFn<TContext[K]>; } | undefined;
}
/** Options for machine hooks */
interface HookOptions<TContext extends Dict, TState extends StateSchema, TEvent extends EventObject> {
  /** Synchronous execution mode */
  sync?: boolean;
  /** Action implementations */
  actions?: ActionMap<TContext, TState, TEvent> | undefined;
  /** Initial state */
  state?: StateInit<TContext, TState> | undefined;
  /** Initial context */
  context?: UserContext<TContext> | undefined;
}
/** Machine self-reference for advanced operations */
interface XSelf<TContext extends Dict, TState extends StateSchema, TEvent extends EventObject> {
  /** Machine identifier */
  id: string;
  /** Send event to this machine */
  send: (event: Event<TEvent>) => void;
  /** Send event to parent machine */
  sendParent: (evt: AnyEventObject) => void;
  /** Send event to child machine */
  sendChild: (evt: Event<TEvent>, to: string | ((ctx: TContext) => string)) => void;
  /** Stop this machine */
  stop: VoidFunction;
  /** Stop child machine */
  stopChild: (id: string) => void;
  /** Stop activity */
  stopActivity: (id: string) => void;
  /** Spawn new actor */
  spawn: <T>(src: T | (() => T), id?: string) => T;
  /** Current state */
  state: XState<TContext, TState, TEvent>;
  /** Initial context */
  initialContext: TContext;
  /** Initial state */
  initialState: string;
}
/** Machine status enumeration */
export declare enum MachineStatus {
  NotStarted = "Not Started",
  Running = "Running",
  Stopped = "Stopped"
}
/** Built-in action types */
export declare enum ActionTypes {
  Start = "machine.start",
  Stop = "machine.stop",
  Created = "machine.created",
  Init = "machine.init"
}
/** Machine type enumeration */
export declare enum MachineType {
  Machine = "machine",
  Actor = "machine.actor"
}
/** Comparison function type */
type CompareFn<T = any> = (prev: T, next: T) => boolean;
type AnyFunction = (...args: any[]) => any;
type ReturnTypeOrValue<T> = T extends AnyFunction ? ReturnType<T> : T;
type StateFrom<T> = ReturnTypeOrValue<T> extends (infer R) ? R extends Machine<infer TContext, infer TState, infer TEvent> ? XState<TContext, TState, TEvent> : never : never;
type ContextFrom<T> = ReturnTypeOrValue<T> extends (infer R) ? (R extends Machine<infer TContext, any, any> ? TContext : never) : never;
type EventFrom<T> = ReturnTypeOrValue<T> extends (infer R) ? (R extends Machine<any, any, infer TEvent> ? TEvent : never) : never;
interface ContextRef<T> {
  current: T | undefined;
}
//#endregion
//#region src/guard-utils.d.ts
declare function or<TContext extends Dict, TState extends StateSchema, TEvent extends EventObject>(...conditions: Array<Guard<TContext, TState, TEvent>>): GuardHelper<TContext, TState, TEvent>;
declare function and<TContext extends Dict, TState extends StateSchema, TEvent extends EventObject>(...conditions: Array<Guard<TContext, TState, TEvent>>): GuardHelper<TContext, TState, TEvent>;
declare function not<TContext extends Dict, TState extends StateSchema, TEvent extends EventObject>(condition: Guard<TContext, TState, TEvent>): GuardHelper<TContext, TState, TEvent>;
declare function stateIn<TContext extends Dict, TState extends StateSchema, TEvent extends EventObject>(...values: TState['value'][]): GuardExpression<TContext, TState, TEvent>;
export declare const guards: {
  or: typeof or;
  and: typeof and;
  not: typeof not;
  stateIn: typeof stateIn;
};
export declare function choose<TContext extends Dict, TState extends StateSchema, TEvent extends EventObject = AnyEventObject>(actions: Array<{
  guard?: Guard<TContext, TState, TEvent>;
  actions: PureActions<TContext, TState, TEvent>;
}>): ChooseHelper<TContext, TState, TEvent>;
//#endregion
//#region src/merge-props.d.ts
interface Props {
  [key: string]: any;
}
type TupleTypes<T extends any[]> = T[number];
type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
export declare function mergeProps<T extends Props>(...args: T[]): UnionToIntersection<TupleTypes<T[]>>;
//#endregion
export { type Action, type ActionMap, type Actions, type Activities, type Activity, type ActivityMap, type AnyEventObject, type ChooseHelper, type Context, type ContextFrom, type ContextListener, type ContextRef, type Delay, type DelayExpression, type DelayMap, type DelayedTransition, type DelayedTransitions, type Event, type EventFrom, type EventListener, type EventObject, type ExtractEvent, type Guard, type GuardExpression, type GuardHelper, type GuardMap, type GuardMeta, type HookOptions, type MachineConfig, type MachineOptions, type Meta, type PureActions, type Ref, type StateFrom, type StateInfo, type StateInit, type StateInitObject, type StateListener, type StateNode, type StateSchema, type TComputedContext, type Transition, type TransitionDefinition, type TransitionDefinitionMap, type Transitions, type UserContext, type XSelf, type XSend, type XState, proxy, ref, snapshot, subscribe };