export declare const createStateMachine: <
  SMS extends StateMachineSpec<keyof SMS['states'], keyof SMS['events']>
>(
  spec: SMS
) => StateMachine<SMS>

import { createStateMachine } from '@ts-stadium/state-machine'

const stateMachine = createStateMachine({
  states: {
    On: { events: ['Toggle'] },
    Off: { events: ['Toggle'] },
  },
  events: {
    Toggle: { toStates: ['On', 'Off'] },
  },
})

export type CoStateToEvent<
  SM extends StateMachine,
  E extends Event<SM>
> = ExtendsGuard<ImplCoStateToEvent<SM, E>, State<SM>>

export type Event<SM extends StateMachine> = ExtendsGuard<ImplEvent<SM>, Name>

export type EventData<SM extends StateMachine> = ImplEventData<SM>

export type EventToEvent<
  SM extends StateMachine,
  E extends Event<SM>
> = ExtendsGuard<ImplEvenToEvent<SM, E>, Event<SM>>

export type EventToState<
  SM extends StateMachine,
  E extends Event<SM>
> = ExtendsGuard<ImplEventToState<SM, E>, State<SM>>

export type InitState<T extends StateMachine['states']> = T[Union<
  InitStates<T>
>]['data']

export type InitStates<T extends StateMachine['states']> = {
  [S in keyof T]: true extends T[S]['init'] ? S : never
}

export type State<T extends { states: Record<Name, any> }> = keyof T['states']

export type StateData<SM extends StateMachine> = ImplStateData<SM>

export type StateToEvent<
  S extends State<SM>,
  SM extends StateMachine
> = TupleToUnion<SM['states'][S]['events']>

export declare const coStateToEvent: <SM extends StateMachine_>(
  stateMachine: SM,
  event: keyof SM['events']
) => (keyof SM['states'])[]

export declare const stateToEvents: <
  SM extends StateMachine<
    StateMachineSpec<string | number | symbol, string | number | symbol>
  >
>(
  stateMachine: SM,
  state: keyof SM['states']
) => (keyof SM['events'])[]

export type MapData<T extends Record<Name, { data: any }>> = {
  [E in keyof T]: T[E]['data']
}

export type Name = string | symbol | number

export interface StateMachine<SMS extends StateMachineSpec = StateMachineSpec>
  extends ImplStateMachine<SMS> {
  readonly StateMachine: unique symbol
}

export interface StateMachineSpec<
  S extends Name = Name,
  E extends Name = Name
> {
  states: Record<
    S,
    {
      data?: any
      events?: Tuple<E>
      init?: boolean
    }
  >

  events: Record<
    E,
    {
      data?: any
      toStates?: Tuple<S>
      toEvents?: Tuple<E>
    }
  >
}

export declare const init: <SM extends StateMachine_>(
  stateMachine: SM,
  initState: InitState<SM['states']>
) => Union<MapData<SM['states']>>