@stateforward/hsm.ts 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,1013 @@
+import { Kind } from './kind.cjs';
+export { isKind as IsKind, kinds as Kinds, makeKind as MakeKind, isKind, kinds, makeKind } from './kind.cjs';
+export { Generator, MUID, MuidConfig, ShardedGenerators, UInt64, add64, and64, cmp64, from32, getDefaultConfig, make, make64, makeMuid, newGenerator, or64, shl64, shr64, sub64 } from './muid.cjs';
+
+type Path = string;
+type TimerHandle = ReturnType<typeof setTimeout>;
+type TimerFunction = (callback: (...args: Array<unknown>) => void, timeout?: number, ...args: Array<unknown>) => TimerHandle;
+type CancelFunction = (id: TimerHandle | undefined) => void;
+type AnyModelElement = State | Transition | Behavior | Constraint | Vertex;
+type EventRecord = {
+    kind: Kind;
+    name: string;
+    data?: any;
+    schema?: any;
+    source?: string;
+    target?: string;
+    id?: string;
+    qualifiedName?: string;
+};
+type Element = {
+    kind: Kind;
+    qualifiedName: Path;
+    id?: string;
+};
+type Vertex = Element & {
+    transitions: Path[];
+};
+type TransitionPath = {
+    enter: Path[];
+    exit: Path[];
+};
+type AttributeDefinition = {
+    name: string;
+    qualifiedName: string;
+    hasDefault: boolean;
+    defaultValue?: any;
+};
+type OperationDefinition = {
+    name: string;
+    qualifiedName: string;
+    implementation: (...args: unknown[]) => unknown;
+};
+type Model = State & {
+    members: Record<Path, AnyModelElement>;
+    transitionMap: Record<Path, Record<Path, any[]>>;
+    deferredMap: Record<Path, Record<Path, boolean>>;
+    events: Record<string, EventRecord>;
+    attributes: Record<string, AttributeDefinition>;
+    operations: Record<string, OperationDefinition>;
+    partials: Array<(model: Model, stack: AnyModelElement[]) => void>;
+};
+type Expression = (ctx: Context, instance: Instance, event: EventRecord) => boolean;
+type TimeExpression = (ctx: Context, instance: Instance, event: EventRecord) => number | Date | Promise<number> | Promise<Date>;
+type Behavior = Element & {
+    operation: Operation | null;
+    operationName?: string;
+    Owner?: () => string;
+};
+type Constraint = Element & {
+    expression: Expression;
+};
+type Snapshot = {
+    id: string;
+    qualifiedName: string;
+    state: string;
+    attributes: Record<string, any>;
+    queueLen: number;
+    events: Array<{
+        event: string;
+        target?: string;
+        guard: boolean;
+        schema?: any;
+    }>;
+};
+type Config = {
+    id?: string;
+    name?: string;
+    data?: any;
+    clock?: {
+        setTimeout?: TimerFunction;
+        clearTimeout?: CancelFunction;
+        now?: () => number;
+    };
+};
+type ClockConfig = {
+    setTimeout: TimerFunction;
+    clearTimeout: CancelFunction;
+    now: () => number;
+};
+type StripLeadingSlash<S extends string> = S extends `/${infer Rest}` ? Rest : S;
+type StripTrailingSlash<S extends string> = S extends `${infer Rest}/` ? Rest : S;
+type PathParts<S extends string> = S extends '' ? [] : S extends `${infer Head}/${infer Tail}` ? [Head, ...PathParts<Tail>] : [S];
+type CompactPathParts<Parts extends readonly string[], Acc extends readonly string[] = []> = Parts extends readonly [infer Head extends string, ...infer Tail extends string[]] ? Head extends '.' ? CompactPathParts<Tail, Acc> : Head extends '' ? CompactPathParts<Tail, Acc> : Head extends '..' ? CompactPathParts<Tail, PopSegment<Acc>> : CompactPathParts<Tail, [...Acc, Head]> : Acc;
+type JoinPathParts<Parts extends readonly string[]> = Parts extends [] ? '' : Parts extends readonly [infer Head extends string] ? Head : Parts extends readonly [infer Head extends string, ...infer Tail extends string[]] ? `${Head}/${JoinPathParts<Tail>}` : string;
+type NormalizePath<Raw extends string> = ToAbsolutePath<CompactPathParts<PathParts<Raw>>>;
+type ToAbsolutePath<Parts extends readonly string[]> = Parts extends [] ? '/' : `/${JoinPathParts<Parts>}`;
+type PopSegment<Parts extends readonly string[]> = Parts extends readonly [...infer Rest extends string[], infer _Last] ? Rest : [];
+type IsAbsolutePath<S extends string> = S extends `/${string}` ? true : false;
+type ResolvePathExpression<Base extends string, Expr extends string> = IsAbsolutePath<Expr> extends true ? NormalizePath<Expr> : ToAbsolutePath<CompactPathParts<[
+    ...PathParts<StripLeadingSlash<Base>>,
+    ...PathParts<StripLeadingSlash<StripTrailingSlash<Expr>>>
+]>>;
+type ResolveModelPathExpression<Owner extends string, ModelRoot extends string, Expr extends string> = IsAbsolutePath<Expr> extends true ? IsPathUnderBase<NormalizePath<Expr>, ModelRoot> extends true ? NormalizePath<Expr> : ToAbsolutePath<CompactPathParts<[
+    ...PathParts<StripLeadingSlash<ModelRoot>>,
+    ...PathParts<StripLeadingSlash<StripTrailingSlash<Expr>>>
+]>> : ToAbsolutePath<CompactPathParts<[
+    ...PathParts<StripLeadingSlash<Owner>>,
+    ...PathParts<StripLeadingSlash<StripTrailingSlash<Expr>>>
+]>>;
+type IsPathUnderBase<Path extends string, Base extends string> = Path extends Base | `${Base}/${string}` ? true : false;
+type RelativeFromAbsolute<Path extends string> = Path extends `/${string}/${infer Rest}` ? Rest : never;
+type ParentParts<Parts extends readonly string[]> = Parts extends readonly [...infer Prefix extends string[], infer _Last extends string] ? Prefix : [];
+type ParentPath<Path extends string> = Path extends `/${infer Tail}` ? ToAbsolutePath<ParentParts<PathParts<Tail>>> : never;
+type IsStatePathPrefix<Prefix extends string, Path extends string> = Path extends `${Prefix}/${string}` ? true : false;
+interface TypedModel<TAttributes extends Record<string, any> = Record<string, any>, TOperations extends Record<string, (...args: any[]) => any> = Record<string, (...args: any[]) => any>, TGuards extends Record<string, (...args: any[]) => any> = Record<string, (...args: any[]) => any>, TActivities extends Record<string, (...args: any[]) => any> = Record<string, (...args: any[]) => any>, TEvents = Event<string, unknown>, TEventGroups = unknown, TName extends string = string, TInstance extends Instance = Instance> extends Model {
+    readonly __hsm_attributes?: TAttributes;
+    readonly __hsm_operations?: TOperations;
+    readonly __hsm_guards?: TGuards;
+    readonly __hsm_activities?: TActivities;
+    readonly __hsm_events?: TEvents;
+    readonly __hsm_eventGroups?: TEventGroups;
+    readonly __hsm_name?: TName;
+    readonly __hsm_instance?: TInstance;
+    readonly __hsm_meta?: {
+        name: unknown;
+        states: unknown;
+        finalStates: unknown;
+        transitions: unknown;
+        initials: unknown;
+        attributes: unknown;
+        operations: unknown;
+        eventSchemas: unknown;
+    };
+}
+type EventClause<Name extends string = string, Schema = unknown> = {
+    kind: 'on';
+    name: Name;
+    schema?: Schema;
+};
+type OnSetClause<Name extends string = string> = {
+    kind: 'onSet';
+    name: Name;
+};
+type OnCallClause<Name extends string = string> = {
+    kind: 'onCall';
+    name: Name;
+};
+type WhenClause<Name extends string = string> = {
+    kind: 'when';
+    name: Name;
+};
+type WhenExprClause = {
+    kind: 'whenExpr';
+};
+type SourceClause<Name extends string = string> = {
+    kind: 'source';
+    name: Name;
+};
+type TargetClause<Name extends string = string> = {
+    kind: 'target';
+    name: Name;
+};
+type GuardClause<Value = unknown> = {
+    kind: 'guard';
+    value: Value;
+};
+type EffectClause<Value = unknown> = {
+    kind: 'effect';
+    value: Value;
+};
+type AfterClause<Value = unknown> = {
+    kind: 'after';
+    value: Value;
+};
+type EveryClause<Value = unknown> = {
+    kind: 'every';
+    value: Value;
+};
+type AtClause<Value = unknown> = {
+    kind: 'at';
+    value: Value;
+};
+type TransitionSpec<Parts extends readonly TransitionBuilderClause[]> = {
+    kind: 'transition';
+    parts: Parts;
+};
+type StateSpec<Name extends string = string, Parts extends readonly unknown[] = readonly unknown[]> = {
+    kind: 'state';
+    name: Name;
+    parts: Parts;
+};
+type InitialSpec<Parts extends readonly TransitionBuilderClause[] = readonly TransitionBuilderClause[]> = {
+    kind: 'initial';
+    name: string;
+    parts: Parts;
+};
+type FinalSpec<Name extends string = string> = {
+    kind: 'final';
+    name: Name;
+};
+type ShallowHistorySpec<Name extends string = string, Parts extends readonly unknown[] = readonly unknown[]> = {
+    kind: 'shallowHistory';
+    name: Name;
+    parts: Parts;
+};
+type DeepHistorySpec<Name extends string = string, Parts extends readonly unknown[] = readonly unknown[]> = {
+    kind: 'deepHistory';
+    name: Name;
+    parts: Parts;
+};
+type ChoiceSpec<Name extends string = string, Parts extends readonly unknown[] = readonly unknown[]> = {
+    kind: 'choice';
+    name: Name;
+    parts: Parts;
+};
+type EntrySpec<Operations = unknown> = {
+    kind: 'entry';
+    value: Operations;
+};
+type ExitSpec<Operations = unknown> = {
+    kind: 'exit';
+    value: Operations;
+};
+type ActivitySpec<Operations = unknown> = {
+    kind: 'activity';
+    value: Operations;
+};
+type DeferSpec<EventNames extends readonly string[] = readonly string[]> = {
+    kind: 'defer';
+    eventNames: EventNames;
+};
+type AttributeSpec<Name extends string = string, Value = unknown> = {
+    kind: 'attribute';
+    name: Name;
+    value: Value;
+};
+type OperationSpec<Name extends string = string, Fn extends (...args: any[]) => any = (...args: any[]) => any> = {
+    kind: 'operation';
+    name: Name;
+    impl: Fn;
+};
+type ModelElementSpec = TransitionSpec<readonly TransitionBuilderClause[]> | StateSpec<string, readonly unknown[]> | InitialSpec<readonly TransitionBuilderClause[]> | FinalSpec | ShallowHistorySpec<string, readonly unknown[]> | DeepHistorySpec<string, readonly unknown[]> | ChoiceSpec<string, readonly unknown[]> | EntrySpec | ExitSpec | ActivitySpec | AttributeSpec | OperationSpec | DeferSpec | {
+    kind: 'unknown';
+};
+type TransitionBuilderClause = EventClause | OnSetClause | OnCallClause | WhenClause | WhenExprClause | SourceClause | TargetClause | GuardClause | EffectClause | AfterClause | EveryClause | AtClause | {
+    kind: 'unknownTransitionClause';
+};
+type ModelMetaOf<T> = T extends {
+    __hsm_meta: infer M;
+} ? M : never;
+type BuilderTuple<Specs extends readonly unknown[]> = {
+    [K in keyof Specs]: BuilderWithSpec<(model: Model, stack: AnyModelElement[]) => unknown, Specs[K]>;
+};
+type GuardBuilder<EventType extends EventRecord = EventRecord> = BuilderWithSpec<(model: Model, stack: AnyModelElement[]) => unknown, GuardClause<unknown>> & {
+    readonly __hsmTransitionEvent?: EventType;
+};
+type TransitionBuilderTuple<Clauses extends readonly TransitionBuilderClause[]> = BuilderTuple<Clauses>;
+type ScopeModelParts<LocalParts extends readonly unknown[], ModelParts extends readonly unknown[]> = readonly [...ModelParts, ...LocalParts];
+type IsAny<T> = 0 extends (1 & T) ? true : false;
+type AttributeKeysFromModelParts<Parts extends readonly unknown[]> = keyof ModelAttributeTypeMap<Parts> & string;
+type DurationAttributeKeysFromModelParts<Parts extends readonly unknown[]> = {
+    [K in AttributeKeysFromModelParts<Parts>]: IsAny<EventValueFromAttribute<Parts, K>> extends true ? K : [Extract<EventValueFromAttribute<Parts, K>, string | number>] extends [never] ? never : K;
+}[AttributeKeysFromModelParts<Parts>];
+type TimepointAttributeKeysFromModelParts<Parts extends readonly unknown[]> = {
+    [K in AttributeKeysFromModelParts<Parts>]: IsAny<EventValueFromAttribute<Parts, K>> extends true ? K : [Extract<EventValueFromAttribute<Parts, K>, string | number | Date>] extends [never] ? never : K;
+}[AttributeKeysFromModelParts<Parts>];
+type OperationKeysFromModelParts<Parts extends readonly unknown[]> = keyof ModelOperationTypeMap<Parts> & string;
+type GuardOperationKeysFromModelParts<Parts extends readonly unknown[]> = {
+    [K in OperationKeysFromModelParts<Parts>]: IsAny<ReturnType<Extract<ModelOperationTypeMap<Parts>[K], (...args: any[]) => any>>> extends true ? never : ReturnType<Extract<ModelOperationTypeMap<Parts>[K], (...args: any[]) => any>> extends boolean ? K : never;
+}[OperationKeysFromModelParts<Parts>];
+type InvalidString<Message extends string, Actual extends string> = Actual & {
+    readonly __hsmTypeError: Message;
+};
+type ValidateBehaviorArgument<Argument, ModelParts extends readonly unknown[], GuardOnly extends boolean = false> = Argument extends string ? GuardOnly extends true ? Argument extends GuardOperationKeysFromModelParts<ModelParts> ? Argument : InvalidString<`Invalid guard operation: ${Argument}`, Argument> : Argument extends OperationKeysFromModelParts<ModelParts> ? Argument : InvalidString<`Invalid behavior operation: ${Argument}`, Argument> : Argument;
+type ValidateBehaviorArguments<Arguments, ModelParts extends readonly unknown[], GuardOnly extends boolean = false> = Arguments extends readonly [infer Head, ...infer Tail] ? readonly [
+    ValidateBehaviorArgument<Head, ModelParts, GuardOnly>,
+    ...ValidateBehaviorArguments<Tail, ModelParts, GuardOnly>
+] : readonly [];
+type KnownEventNamesFromRootModelParts<RootModelParts extends readonly unknown[], RootPath extends string> = keyof CollectModelParts<RootModelParts, RootPath, RootPath, RootModelParts>['eventSchemas'] & string;
+type ValidateDeferredEventName<EventName extends string, RootModelParts extends readonly unknown[], RootPath extends string> = string extends EventName ? EventName : EventName extends KnownEventNamesFromRootModelParts<RootModelParts, RootPath> ? EventName : InvalidString<`Invalid deferred event: ${EventName}`, EventName>;
+type ValidateDeferredEventNames<EventNames extends readonly string[], RootModelParts extends readonly unknown[], RootPath extends string> = {
+    [K in keyof EventNames]: EventNames[K] extends string ? ValidateDeferredEventName<EventNames[K], RootModelParts, RootPath> : EventNames[K];
+};
+type LocalKnownEventNamesFromParts<Parts extends readonly unknown[]> = keyof CollectModelParts<Parts, '/', '/', Parts>['eventSchemas'] & string;
+type ValidateDeferredEventNameFromParts<EventName extends string, Parts extends readonly unknown[]> = string extends EventName ? EventName : EventName extends LocalKnownEventNamesFromParts<Parts> ? EventName : InvalidString<`Invalid deferred event: ${EventName}`, EventName>;
+type ValidateDeferredEventNamesFromParts<EventNames extends readonly string[], Parts extends readonly unknown[]> = {
+    [K in keyof EventNames]: EventNames[K] extends string ? ValidateDeferredEventNameFromParts<EventNames[K], Parts> : EventNames[K];
+};
+type ValidateStateLocalSpec<Spec, RootParts extends readonly unknown[]> = Spec extends DeferSpec<infer EventNames> ? DeferSpec<ValidateDeferredEventNamesFromParts<EventNames, RootParts>> : Spec extends StateSpec<infer Name, infer Parts> ? StateSpec<Name, ValidateStateLocalSpecs<Parts, RootParts>> : Spec;
+type ValidateStateLocalSpecs<Specs extends readonly unknown[], RootParts extends readonly unknown[] = Specs> = {
+    [K in keyof Specs]: ValidateStateLocalSpec<Specs[K], RootParts>;
+};
+type ValidateTransitionClause<Clause, ScopedModelParts extends readonly unknown[], RootModelParts extends readonly unknown[], RootPath extends string, OwnerPath extends string> = Clause extends OnSetClause<infer Name> ? Name extends AttributeKeysFromModelParts<ScopedModelParts> ? OnSetClause<Name> : OnSetClause<InvalidString<`Invalid onSet attribute: ${Name}`, Name>> : Clause extends WhenClause<infer Name> ? Name extends AttributeKeysFromModelParts<ScopedModelParts> ? WhenClause<Name> : WhenClause<InvalidString<`Invalid when attribute: ${Name}`, Name>> : Clause extends OnCallClause<infer Name> ? Name extends OperationKeysFromModelParts<ScopedModelParts> ? OnCallClause<Name> : OnCallClause<InvalidString<`Invalid onCall operation: ${Name}`, Name>> : Clause extends SourceClause<infer Name> ? ResolveModelPathExpression<OwnerPath, RootPath, Name> extends RootPath | CollectModelParts<RootModelParts, RootPath, RootPath, RootModelParts>['states'] ? SourceClause<Name> : SourceClause<InvalidString<`Invalid transition source path: ${Name}`, Name>> : Clause extends TargetClause<infer Name> ? ResolveModelPathExpression<OwnerPath, RootPath, Name> extends RootPath | CollectModelParts<RootModelParts, RootPath, RootPath, RootModelParts>['states'] ? TargetClause<Name> : TargetClause<InvalidString<`Invalid transition target path: ${Name}`, Name>> : Clause extends AfterClause<infer Value> ? Value extends string ? Value extends DurationAttributeKeysFromModelParts<ScopedModelParts> ? AfterClause<Value> : AfterClause<InvalidString<`Invalid after attribute: ${Value}`, Value>> : Clause : Clause extends EveryClause<infer Value> ? Value extends string ? Value extends DurationAttributeKeysFromModelParts<ScopedModelParts> ? EveryClause<Value> : EveryClause<InvalidString<`Invalid every attribute: ${Value}`, Value>> : Clause : Clause extends AtClause<infer Value> ? Value extends string ? Value extends TimepointAttributeKeysFromModelParts<ScopedModelParts> ? AtClause<Value> : AtClause<InvalidString<`Invalid at attribute: ${Value}`, Value>> : Clause : Clause extends GuardClause<infer Value> ? GuardClause<ValidateBehaviorArgument<Value, ScopedModelParts, true>> : Clause extends EffectClause<infer Value> ? EffectClause<ValidateBehaviorArguments<Value, ScopedModelParts>> : Clause;
+type ValidateTransitionClauses<Clauses extends readonly unknown[], ScopedModelParts extends readonly unknown[], RootModelParts extends readonly unknown[], RootPath extends string, OwnerPath extends string> = {
+    [K in keyof Clauses]: ValidateTransitionClause<Clauses[K], ScopedModelParts, RootModelParts, RootPath, OwnerPath>;
+};
+type ValidateModelSpec<Spec, ScopedModelParts extends readonly unknown[], RootModelParts extends readonly unknown[], RootPath extends string, OwnerPath extends string> = Spec extends StateSpec<infer Name, infer Parts> ? StateSpec<Name, ValidateModelSpecs<Parts, ScopeModelParts<Parts, ScopedModelParts>, RootModelParts, RootPath, ResolvePathExpression<OwnerPath, Name>>> : Spec extends TransitionSpec<infer Clauses> ? TransitionSpec<ValidateTransitionClauses<Clauses, ScopedModelParts, RootModelParts, RootPath, OwnerPath>> : Spec extends InitialSpec<infer Clauses> ? InitialSpec<ValidateTransitionClauses<Clauses, ScopedModelParts, RootModelParts, RootPath, OwnerPath>> : Spec extends EntrySpec<infer Value> ? EntrySpec<ValidateBehaviorArguments<Value, ScopedModelParts>> : Spec extends ExitSpec<infer Value> ? ExitSpec<ValidateBehaviorArguments<Value, ScopedModelParts>> : Spec extends ActivitySpec<infer Value> ? ActivitySpec<ValidateBehaviorArguments<Value, ScopedModelParts>> : Spec extends DeferSpec<infer EventNames> ? DeferSpec<ValidateDeferredEventNames<EventNames, RootModelParts, RootPath>> : Spec;
+type ValidateModelSpecs<Specs extends readonly unknown[], ScopedModelParts extends readonly unknown[] = Specs, RootModelParts extends readonly unknown[] = ScopedModelParts, RootPath extends string = '/', OwnerPath extends string = RootPath> = {
+    [K in keyof Specs]: ValidateModelSpec<Specs[K], ScopedModelParts, RootModelParts, RootPath, OwnerPath>;
+};
+type ValidatedModelElementBuilderTuple<Specs extends readonly ModelElementSpec[], ScopedModelParts extends readonly ModelElementSpec[] = Specs, RootModelParts extends readonly ModelElementSpec[] = ScopedModelParts, RootPath extends string = '/', OwnerPath extends string = RootPath> = BuilderTuple<ValidateModelSpecs<Specs, ScopedModelParts, RootModelParts, RootPath, OwnerPath>>;
+type ModelAttributeMap<T> = T extends TypedModel<infer A, any, any, any, any, any, any, any> ? A : ModelMetaOf<T> extends {
+    attributes: infer A;
+} ? A extends Record<string, unknown> ? A : {} : {};
+type ModelOperationMap<T> = T extends TypedModel<any, infer O, any, any, any, any, any, any> ? O : ModelMetaOf<T> extends {
+    operations: infer O;
+} ? O extends Record<string, (...args: any[]) => any> ? O : {} : {};
+type ModelEventMap<T> = T extends TypedModel<any, any, any, any, infer E, any, any, any> ? EventMapFromUnion<E> : ModelMetaOf<T> extends {
+    eventSchemas: infer E;
+} ? E extends Record<string, unknown> ? E : {} : {};
+type ModelStateMeta<T> = T extends {
+    __hsm_meta: infer Meta;
+} ? Meta extends {
+    name: string;
+    states: infer States;
+    finalStates: infer Finals;
+    transitions: infer Transitions;
+    initials: infer Initials;
+    attributes: infer Attributes;
+    operations: infer Operations;
+    eventSchemas: infer EventSchemas;
+} ? {
+    name: string & Meta['name'];
+    states: States & string;
+    finalStates: Finals & string;
+    transitions: Transitions;
+    initials: Initials extends Record<string, string> ? Initials : Record<string, string>;
+    attributes: Attributes extends Record<string, unknown> ? Attributes : Record<string, unknown>;
+    operations: Operations extends Record<string, (...args: any[]) => any> ? Operations : Record<string, (...args: any[]) => any>;
+    eventSchemas: EventSchemas extends Record<string, unknown> ? EventSchemas : Record<string, unknown>;
+} : never : TypedModelMetaFallback<T>;
+type TypedModelMetaFallback<T> = {
+    name: string;
+    states: string;
+    finalStates: string;
+    transitions: string;
+    initials: Record<string, string>;
+    attributes: ModelAttributeMap<T>;
+    operations: ModelOperationMap<T>;
+    eventSchemas: ModelEventMap<T>;
+};
+type TypedModelFromInfer<RootName extends string, Parts extends readonly unknown[]> = {
+    [K in keyof Model & string]: Model[K];
+} & TypedModel<InferredAttributes<Parts>, InferredOperations<Parts>, any, any, InferredEventUnion<Parts>, any, RootName, Instance> & {
+    readonly __hsm_meta: ModelStateMetaFromParts<`/${RootName}`, Parts>;
+};
+type ModelAttributeTypeMap<Parts extends readonly unknown[]> = MergeMaps<AttributeFromParts<Parts>>;
+type ModelOperationTypeMap<Parts extends readonly unknown[]> = NormalizeOpMap<MergeMaps<OperationFromParts<Parts>>>;
+type InferredAttributes<Parts extends readonly unknown[]> = ModelAttributeTypeMap<Parts>;
+type InferredOperations<Parts extends readonly unknown[]> = ModelOperationTypeMap<Parts>;
+type InferredEventUnion<Parts extends readonly unknown[]> = EventUnionFromTransitions<CollectModelParts<Parts, '/', '/', Parts>['transitions']> | EventUnionFromMap<CollectModelParts<Parts, '/', '/', Parts>['eventSchemas']>;
+type UnionToIntersection<T> = (T extends any ? (value: T) => void : never) extends (value: infer I) => void ? I : never;
+type EventMapFromUnion<U> = UnionToIntersection<U extends Event<infer Name, infer Schema> ? {
+    [K in Name]: Schema;
+} : {}> extends infer M ? M extends Record<string, unknown> ? MergeMaps<M> : {} : {};
+type MergeEventMaps<A extends Record<string, unknown>, B extends Record<string, unknown>> = {
+    [K in keyof A | keyof B]: K extends keyof B ? B[K] : K extends keyof A ? A[K] : never;
+};
+type MergeMaps<M extends Record<string, unknown>> = {
+    [K in keyof M]: M[K];
+};
+type NormalizeOpMap<M extends Record<string, unknown>> = {
+    [K in keyof M]: M[K] extends (...args: any[]) => any ? M[K] : never;
+};
+type AttributeFromParts<Parts extends readonly unknown[]> = Parts extends readonly [infer H, ...infer T] ? H extends AttributeSpec<infer Name, infer Value> ? {
+    [K in Name]: Value;
+} & AttributeFromParts<T> : AttributeFromParts<T> : {};
+type OperationFromParts<Parts extends readonly unknown[]> = Parts extends readonly [infer H, ...infer T] ? H extends OperationSpec<infer Name, infer Fn> ? {
+    [K in Name]: Fn;
+} & OperationFromParts<T> : OperationFromParts<T> : {};
+type EventValueFromAttribute<Parts extends readonly unknown[], Name extends string> = Name extends keyof ModelAttributeTypeMap<Parts> & string ? ModelAttributeTypeMap<Parts>[Name] : unknown;
+type EventArgsFromOperation<Parts extends readonly unknown[], Name extends string> = Name extends keyof ModelOperationTypeMap<Parts> & string ? Parameters<Extract<ModelOperationTypeMap<Parts>[Name], (...args: any[]) => any>> : unknown[];
+type EventSchemasFromPartialsWithContext<Parts extends readonly unknown[], ModelParts extends readonly unknown[]> = Parts extends readonly [infer H, ...infer T] ? H extends EventClause<infer Name, infer Schema> ? {
+    [K in Name]: Schema extends undefined ? unknown : Schema;
+} & EventSchemasFromPartialsWithContext<T, ModelParts> : H extends OnSetClause<infer Name> ? {
+    [K in `set:${Name}`]: {
+        name: Name;
+        old: EventValueFromAttribute<ModelParts, Name>;
+        new: EventValueFromAttribute<ModelParts, Name>;
+    };
+} & EventSchemasFromPartialsWithContext<T, ModelParts> : H extends OnCallClause<infer Name> ? {
+    [K in `call:${Name}`]: {
+        name: Name;
+        args: EventArgsFromOperation<ModelParts, Name>;
+    };
+} & EventSchemasFromPartialsWithContext<T, ModelParts> : H extends WhenClause<infer Name> ? {
+    [K in `set:${Name}`]: {
+        name: Name;
+        old: EventValueFromAttribute<ModelParts, Name>;
+        new: EventValueFromAttribute<ModelParts, Name>;
+    };
+} & EventSchemasFromPartialsWithContext<T, ModelParts> : H extends TransitionSpec<infer Clauses> ? EventSchemasFromClausesWithContext<Clauses, ModelParts> & EventSchemasFromPartialsWithContext<T, ModelParts> : H extends StateSpec<infer _Name, infer S> ? EventSchemasFromPartialsWithContext<S, ModelParts> & EventSchemasFromPartialsWithContext<T, ModelParts> : EventSchemasFromPartialsWithContext<T, ModelParts> : {};
+type EventSchemasFromClausesWithContext<Clauses extends readonly unknown[], ModelParts extends readonly unknown[]> = Clauses extends readonly [infer H, ...infer T] ? H extends EventClause<infer Name, infer Schema> ? {
+    [K in Name]: Schema extends undefined ? unknown : Schema;
+} & EventSchemasFromClausesWithContext<T, ModelParts> : H extends OnSetClause<infer Name> ? {
+    [K in `set:${Name}`]: {
+        name: Name;
+        old: EventValueFromAttribute<ModelParts, Name>;
+        new: EventValueFromAttribute<ModelParts, Name>;
+    };
+} & EventSchemasFromClausesWithContext<T, ModelParts> : H extends OnCallClause<infer Name> ? {
+    [K in `call:${Name}`]: {
+        name: Name;
+        args: EventArgsFromOperation<ModelParts, Name>;
+    };
+} & EventSchemasFromClausesWithContext<T, ModelParts> : H extends WhenClause<infer Name> ? {
+    [K in `set:${Name}`]: {
+        name: Name;
+        old: EventValueFromAttribute<ModelParts, Name>;
+        new: EventValueFromAttribute<ModelParts, Name>;
+    };
+} & EventSchemasFromClausesWithContext<T, ModelParts> : EventSchemasFromClausesWithContext<T, ModelParts> : {};
+type TransitionFromClauses<Clauses extends readonly unknown[], Owner extends string = string, Source extends string = Owner, Target extends string | undefined = undefined, Events extends string = never, Schemas extends Record<string, unknown> = {}, ModelParts extends readonly unknown[] = readonly unknown[]> = Clauses extends readonly [infer H, ...infer T] ? H extends SourceClause<infer Name> ? TransitionFromClauses<T, Owner, Name, Target, Events, Schemas, ModelParts> : H extends TargetClause<infer Name> ? TransitionFromClauses<T, Owner, Source, Name, Events, Schemas, ModelParts> : H extends EventClause<infer Name, infer Schema> ? TransitionFromClauses<T, Owner, Source, Target, Events | Name, MergeEventMaps<Schemas, {
+    [K in Name]: Schema extends undefined ? unknown : Schema;
+}>, ModelParts> : H extends OnSetClause<infer Name> ? TransitionFromClauses<T, Owner, Source, Target, Events | `set:${Name}`, MergeEventMaps<Schemas, {
+    [K in `set:${Name}`]: {
+        name: Name;
+        old: EventValueFromAttribute<ModelParts, Name>;
+        new: EventValueFromAttribute<ModelParts, Name>;
+    };
+}>, ModelParts> : H extends OnCallClause<infer Name> ? TransitionFromClauses<T, Owner, Source, Target, Events | `call:${Name}`, MergeEventMaps<Schemas, {
+    [K in `call:${Name}`]: {
+        name: Name;
+        args: EventArgsFromOperation<ModelParts, Name>;
+    };
+}>, ModelParts> : H extends WhenClause<infer Name> ? TransitionFromClauses<T, Owner, Source, Target, Events | `set:${Name}`, MergeEventMaps<Schemas, {
+    [K in `set:${Name}`]: {
+        name: Name;
+        old: EventValueFromAttribute<ModelParts, Name>;
+        new: EventValueFromAttribute<ModelParts, Name>;
+    };
+}>, ModelParts> : TransitionFromClauses<T, Owner, Source, Target, Events, Schemas, ModelParts> : {
+    owner: Owner;
+    source: Source;
+    target: Target;
+    events: Events;
+    schema: Schemas;
+};
+type CollectModelParts<Parts extends readonly unknown[], ParentPath extends string, ModelRoot extends string, AllParts extends readonly unknown[] = Parts> = Parts extends readonly [infer H, ...infer T] ? MergeCollect<InferFromSpec<H, ParentPath, ModelRoot, AllParts>, CollectModelParts<T, ParentPath, ModelRoot, AllParts>> : {
+    states: never;
+    finalStates: never;
+    transitions: never;
+    initials: {};
+    attributes: {};
+    operations: {};
+    eventSchemas: {};
+};
+type InferFromSpec<Spec, ParentPath extends string, ModelRoot extends string, AllParts extends readonly unknown[]> = Spec extends StateSpec<infer Name, infer P> ? StateFromSpec<Name, P, ParentPath, ModelRoot, AllParts> : Spec extends FinalSpec<infer Name> ? FinalFromSpec<Name, ParentPath> : Spec extends TransitionSpec<infer Clauses> ? TransitionFromSpec<Clauses, ParentPath, ModelRoot, AllParts> : Spec extends InitialSpec<infer Clauses> ? InitialFromSpec<Clauses, ParentPath, ModelRoot, AllParts> : Spec extends AttributeSpec<infer Name, infer Value> ? {
+    states: never;
+    finalStates: never;
+    transitions: never;
+    initials: {};
+    attributes: {
+        [K in Name]: Value;
+    };
+    operations: {};
+    eventSchemas: {};
+} : Spec extends OperationSpec<infer Name, infer Fn> ? {
+    states: never;
+    finalStates: never;
+    transitions: never;
+    initials: {};
+    attributes: {};
+    operations: {
+        [K in Name]: Fn;
+    };
+    eventSchemas: {};
+} : Spec extends ShallowHistorySpec<infer Name, infer P> ? StateAliasFromPseudo<Name, P, ParentPath, ModelRoot, AllParts> : Spec extends DeepHistorySpec<infer Name, infer P> ? StateAliasFromPseudo<Name, P, ParentPath, ModelRoot, AllParts> : Spec extends ChoiceSpec<infer Name, infer P> ? StateAliasFromPseudo<Name, P, ParentPath, ModelRoot, AllParts> : {
+    states: never;
+    finalStates: never;
+    transitions: never;
+    initials: {};
+    attributes: {};
+    operations: {};
+    eventSchemas: {};
+};
+type StateAliasFromPseudo<Name extends string, Parts extends readonly unknown[], ParentPath extends string, ModelRoot extends string, AllParts extends readonly unknown[]> = StateFromSpec<Name, Parts, ParentPath, ModelRoot, AllParts>;
+type StateFromSpec<Name extends string, Parts extends readonly unknown[], ParentPath extends string, ModelRoot extends string, AllParts extends readonly unknown[]> = {
+    states: ResolvePathExpression<ParentPath, Name> | ChildTransitionsFromParts<Parts, ResolvePathExpression<ParentPath, Name>, ModelRoot, AllParts>['states'];
+    finalStates: ChildTransitionsFromParts<Parts, ResolvePathExpression<ParentPath, Name>, ModelRoot, AllParts>['finalStates'];
+    transitions: ChildTransitionsFromParts<Parts, ResolvePathExpression<ParentPath, Name>, ModelRoot, AllParts>['transitions'];
+    initials: ChildTransitionsFromParts<Parts, ResolvePathExpression<ParentPath, Name>, ModelRoot, AllParts>['initials'];
+    attributes: ChildTransitionsFromParts<Parts, ResolvePathExpression<ParentPath, Name>, ModelRoot, AllParts>['attributes'];
+    operations: ChildTransitionsFromParts<Parts, ResolvePathExpression<ParentPath, Name>, ModelRoot, AllParts>['operations'];
+    eventSchemas: ChildTransitionsFromParts<Parts, ResolvePathExpression<ParentPath, Name>, ModelRoot, AllParts>['eventSchemas'];
+};
+type ChildTransitionsFromParts<Parts extends readonly unknown[], ParentPath extends string, ModelRoot extends string, AllParts extends readonly unknown[]> = CollectModelParts<Parts, ParentPath, ModelRoot, AllParts>;
+type FinalFromSpec<Name extends string, ParentPath extends string> = {
+    states: ResolvePathExpression<ParentPath, Name>;
+    finalStates: ResolvePathExpression<ParentPath, Name>;
+    transitions: never;
+    initials: {};
+    attributes: {};
+    operations: {};
+    eventSchemas: {};
+};
+type TransitionFromSpec<Clauses extends readonly unknown[], OwnerPath extends string, ModelRoot extends string, ModelParts extends readonly unknown[]> = {
+    states: never;
+    finalStates: never;
+    transitions: NormalizeTransition<TransitionFromClauses<Clauses, OwnerPath, OwnerPath, undefined, never, {}, ModelParts>, OwnerPath, ModelRoot>;
+    attributes: {};
+    operations: {};
+    eventSchemas: EventSchemasFromClausesWithContext<Clauses, ModelParts>;
+    initials: {};
+};
+type InitialsFromClauses<Clauses extends readonly unknown[], OwnerPath extends string, ModelRoot extends string> = NormalizeTransition<TransitionFromClauses<Clauses, OwnerPath, OwnerPath>, OwnerPath, ModelRoot>['target'] extends infer Target ? Target extends string ? {
+    [K in OwnerPath]: Target;
+} : {} : {};
+type InitialFromSpec<Clauses extends readonly unknown[], OwnerPath extends string, ModelRoot extends string, ModelParts extends readonly unknown[]> = {
+    states: never;
+    finalStates: never;
+    transitions: NormalizeTransition<TransitionFromClauses<Clauses, OwnerPath, OwnerPath, undefined, never, {}, ModelParts>, OwnerPath, ModelRoot>;
+    initials: InitialsFromClauses<Clauses, OwnerPath, ModelRoot>;
+    attributes: {};
+    operations: {};
+    eventSchemas: EventSchemasFromClausesWithContext<Clauses, ModelParts>;
+};
+type NormalizeTransition<T extends {
+    owner: string;
+    source: string;
+    target: string | undefined;
+    events: string;
+    schema: Record<string, unknown>;
+}, Owner extends string, Root extends string> = {
+    source: ResolveModelPathExpression<Owner, Root, T['source']>;
+    target: T['target'] extends string ? ResolveModelPathExpression<Owner, Root, T['target']> : undefined;
+    events: T['events'];
+    schema: T['schema'];
+};
+type MergeCollect<A, B> = {
+    states: A extends {
+        states: infer AS;
+    } ? (B extends {
+        states: infer BS;
+    } ? AS | BS : AS) : never;
+    finalStates: A extends {
+        finalStates: infer AF;
+    } ? (B extends {
+        finalStates: infer BF;
+    } ? AF | BF : AF) : never;
+    transitions: A extends {
+        transitions: infer AT;
+    } ? (B extends {
+        transitions: infer BT;
+    } ? AT | BT : AT) : never;
+    initials: A extends {
+        initials: infer AI;
+    } ? B extends {
+        initials: infer BI;
+    } ? MergeEventMaps<AI & Record<string, string>, BI & Record<string, string>> : AI : never;
+    attributes: A extends {
+        attributes: infer AA;
+    } ? B extends {
+        attributes: infer BA;
+    } ? MergeEventMaps<AA & Record<string, unknown>, BA & Record<string, unknown>> : AA : never;
+    operations: A extends {
+        operations: infer AO;
+    } ? B extends {
+        operations: infer BO;
+    } ? MergeEventMaps<AO & Record<string, (...args: any[]) => any>, BO & Record<string, (...args: any[]) => any>> : AO : never;
+    eventSchemas: A extends {
+        eventSchemas: infer AE;
+    } ? B extends {
+        eventSchemas: infer BE;
+    } ? MergeEventMaps<AE & Record<string, unknown>, BE & Record<string, unknown>> : AE : never;
+};
+type ModelStateMetaFromParts<RootPath extends string, Parts extends readonly unknown[]> = {
+    name: RootPath;
+    states: (CollectModelParts<Parts, RootPath, RootPath, Parts>['states']) & string;
+    finalStates: (CollectModelParts<Parts, RootPath, RootPath, Parts>['finalStates']) & string;
+    transitions: CollectModelParts<Parts, RootPath, RootPath, Parts>['transitions'];
+    initials: CollectModelParts<Parts, RootPath, RootPath, Parts>['initials'];
+    attributes: InferredAttributes<Parts>;
+    operations: InferredOperations<Parts>;
+    eventSchemas: MergeEventMaps<EventSchemasFromPartialsWithContext<Parts, Parts>, EventSchemaFromTransitions<CollectModelParts<Parts, RootPath, RootPath, Parts>['transitions']>>;
+};
+type EventSchemaFromTransitions<Transitions> = [
+    Transitions
+] extends [never] ? {} : {
+    [Name in TransitionEventNames<Transitions>]: EventSchemaForTransitionEvent<Transitions, Name>;
+};
+type TransitionEventNames<Transitions> = Transitions extends {
+    events: infer EventName;
+} ? EventName & string : never;
+type EventSchemaForTransitionEvent<Transitions, EventName extends string> = Transitions extends infer Transition ? Transition extends {
+    events: infer E;
+    schema: infer S;
+} ? EventName extends E ? S extends Record<string, unknown> ? EventName extends keyof S ? S[EventName] : unknown : unknown : never : never : never;
+type EventFromSchemaMap<SchemaMap extends Record<string, unknown>> = {
+    [Name in keyof SchemaMap & string]: Event<Name, SchemaMap[Name]>;
+}[keyof SchemaMap & string];
+type EventUnionFromMap<SchemaMap> = SchemaMap extends Record<string, unknown> ? EventFromSchemaMap<SchemaMap> : never;
+type EventUnionFromTransitions<Transitions> = TransitionEventNames<Transitions> extends infer Name ? Name extends string ? Event<Name, EventSchemaForTransitionEvent<Transitions, Name>> : never : never;
+type ModelEventSchemas<M> = ModelStateMeta<M> extends {
+    eventSchemas: infer E;
+} ? E extends Record<string, unknown> ? E : ModelEventMap<M> : ModelEventMap<M>;
+type EventMapKeys<M> = keyof ModelEventSchemas<M> & string;
+type EventSchemaFromMapFor<M, N extends string> = ModelEventMap<M> extends infer E ? E extends Record<string, unknown> ? N extends keyof E ? E[N] : never : never : never;
+type EventSchemaFromTransitionsFor<M, N extends string> = EventSchemaForTransitionEvent<TransitionMetaModel<M>, N>;
+type EventSchemaFor<M, N extends string> = N extends EventMapKeys<M> ? [EventSchemaFromTransitionsFor<M, N>] extends [never] ? [EventSchemaFromMapFor<M, N>] extends [never] ? unknown : EventSchemaFromMapFor<M, N> : EventSchemaFromTransitionsFor<M, N> : unknown;
+type StatePathsOfModel<M> = ModelStateMeta<M>['states'];
+type FinalStatePathsOfModel<M> = ModelStateMeta<M>['finalStates'];
+type TransitionMetaModel<M> = ModelStateMeta<M>['transitions'];
+type EventNamesFromMap<M> = Exclude<EventMapKeys<M>, never>;
+type EventNamesFromTransitions<M> = Exclude<TransitionMetaModel<M>, never> extends infer T ? T extends {
+    events: infer E;
+} ? E : never : never;
+type CompletionStateCandidates<M> = FinalStatePathsOfModel<M> extends infer FinalPath ? FinalPath extends string ? ParentPath<FinalPath> : never : never;
+type StatePathsOf<M extends TypedModel<any, any, any, any, any, any, any, any>> = StatePathsOfModel<M>;
+type RelativeStatePathsOf<M extends TypedModel<any, any, any, any, any, any, any, any>> = RelativeFromAbsolute<StatePathsOf<M>>;
+type LeafStatesOf<M extends TypedModel<any, any, any, any, any, any, any, any>> = StatePathsOf<M> extends infer StatePath ? StatePath extends string ? HasStateDescendant<StatePath, StatePathsOf<M>> extends true ? never : StatePath : never : never;
+type HasStateDescendant<StatePath extends string, Set extends string> = Set extends `${StatePath}/${string}` ? true : false;
+type AttributesOf<M extends TypedModel<any, any, any, any, any, any, any, any>> = ModelStateMeta<M> extends {
+    attributes: infer A;
+} ? A extends Record<string, unknown> ? A : {} : {};
+type AttributeKeysOf<M extends TypedModel<any, any, any, any, any, any, any, any>> = keyof AttributesOf<M> & string;
+type OperationsOf<M extends TypedModel<any, any, any, any, any, any, any, any>> = ModelStateMeta<M> extends {
+    operations: infer O;
+} ? O : ModelOperationMap<M>;
+type OperationKeysOf<M extends TypedModel<any, any, any, any, any, any, any, any>> = keyof OperationsOf<M> & string;
+type CallableOperationKeysOf<M extends TypedModel<any, any, any, any, any, any, any, any>> = OperationKeysOf<M>;
+type GuardOperationKeysOf<M extends TypedModel<any, any, any, any, any, any, any, any>> = {
+    [K in OperationKeysOf<M>]: IsAny<ReturnType<Extract<OperationsOf<M>[K], (...args: any[]) => any>>> extends true ? never : ReturnType<Extract<OperationsOf<M>[K], (...args: any[]) => any>> extends boolean ? K : never;
+}[OperationKeysOf<M>];
+type FinalStatesOf<M extends TypedModel<any, any, any, any, any, any, any, any>> = FinalStatePathsOfModel<M>;
+type IsFinalState<M extends TypedModel<any, any, any, any, any, any, any, any>, Path extends string> = Path extends FinalStatePathsOfModel<M> ? true : false;
+type CompletionStatePathsOf<M extends TypedModel<any, any, any, any, any, any, any, any>> = CompletionStateCandidates<M>;
+type DoneEventNamesOf<M extends TypedModel<any, any, any, any, any, any, any, any>> = CompletionStatePathsOf<M> extends infer CompletionPath ? CompletionPath extends string ? `done:${CompletionPath}` : never : never;
+type DoneEventOf<M extends TypedModel<any, any, any, any, any, any, any, any>> = DoneEventNamesOf<M> extends infer Name ? Name extends string ? Event<Name> : never : never;
+type CompletionEventsOf<M extends TypedModel<any, any, any, any, any, any, any, any>> = DoneEventOf<M>;
+type EventNamesFromState<M extends TypedModel<any, any, any, any, any, any, any, any>, StatePath extends string> = TransitionMetaModel<M> extends infer T ? T extends {
+    source: StatePath;
+    events: infer E;
+} ? E : never : never;
+type EventsForState<M extends TypedModel<any, any, any, any, any, any, any, any>, StatePath extends string> = EventOfName<M, EventNamesFromState<M, StatePath>>;
+type EventNamesOf<M extends TypedModel<any, any, any, any, any, any, any, any>> = Exclude<EventNamesFromMap<M>, DoneEventNamesOf<M>>;
+type EventOfName<M extends TypedModel<any, any, any, any, any, any, any, any>, Name extends string> = Name extends EventNamesOf<M> ? Event<Name, EventSchemaFor<M, Name>> : never;
+type DispatchEvent<Name extends string = string, Data = unknown> = Omit<Event<Name, Data>, 'data'> & {
+    readonly data?: Data;
+};
+type DispatchEventOfName<M extends TypedModel<any, any, any, any, any, any, any, any>, Name extends string> = Name extends EventNamesOf<M> ? EventOfName<M, Name> extends Event<Name, infer Data> ? DispatchEvent<Name, Data> : never : never;
+type DispatchEventsOf<M extends TypedModel<any, any, any, any, any, any, any, any>> = DispatchEventOfName<M, EventNamesOf<M>>;
+type TargetsFromState<M extends TypedModel<any, any, any, any, any, any, any, any>, StatePath extends string> = TransitionMetaModel<M> extends infer T ? T extends {
+    source: StatePath;
+    events: infer _;
+    target: infer Target;
+} ? Target extends string ? Target : never : never : never;
+type TargetsFromStateAndEvent<M extends TypedModel<any, any, any, any, any, any, any, any>, StatePath extends string, EventName extends string> = TransitionMetaModel<M> extends infer T ? T extends {
+    source: StatePath;
+    events: infer E;
+    target: infer Target;
+} ? EventName extends E ? (Target extends string ? Target : never) : never : never : never;
+type SourcesForEvent<M extends TypedModel<any, any, any, any, any, any, any, any>, EventName extends string> = TransitionMetaModel<M> extends infer T ? T extends {
+    source: infer Source;
+    events: infer E;
+} ? EventName extends E ? Source : never : never : never;
+type CanTransition<M extends TypedModel<any, any, any, any, any, any, any, any>, StatePath extends string, TargetPath extends string, EventName extends string> = TargetPath extends TargetsFromStateAndEvent<M, StatePath, EventName> ? true : false;
+type ChildrenOf<M extends TypedModel<any, any, any, any, any, any, any, any>, StatePath extends string> = StatePathsOf<M> extends infer Candidate ? Candidate extends string ? ParentPath<Candidate> extends StatePath ? Candidate : never : never : never;
+type ParentOf<M extends TypedModel<any, any, any, any, any, any, any, any>, StatePath extends string> = ParentPath<StatePath>;
+type DescendantsOf<M extends TypedModel<any, any, any, any, any, any, any, any>, StatePath extends string> = StatePathsOf<M> extends infer Candidate ? Candidate extends `${StatePath}/${string}` ? Candidate : never : never;
+type AncestorsOf<M extends TypedModel<any, any, any, any, any, any, any, any>, StatePath extends string> = StatePathsOf<M> extends infer Candidate ? Candidate extends string ? IsStatePathPrefix<Candidate, StatePath> extends true ? Candidate : never : never : never;
+type InitialStateOf<M extends TypedModel<any, any, any, any, any, any, any, any>, StatePath extends string> = StatePath extends string ? Extract<InitialStateCandidates<M>[StatePath], string> : never;
+type InitialStateCandidates<M extends TypedModel<any, any, any, any, any, any, any, any>> = ModelStateMeta<M>['initials'];
+type SnapshotOf<M extends TypedModel<any, any, any, any, any, any, any, any>> = {
+    id: string;
+    qualifiedName: string;
+    state: StatePathsOf<M>;
+    attributes: AttributesOf<M>;
+    queueLen: number;
+    events: EventSnapshotOf<M>[];
+};
+type EventTargetForName<M extends TypedModel<any, any, any, any, any, any, any, any>, EventName extends string> = TransitionMetaModel<M> extends infer T ? T extends {
+    events: infer E;
+    target: infer Target;
+} ? EventName extends E ? Target : never : never : never;
+type EventSnapshotOf<M extends TypedModel<any, any, any, any, any, any, any, any>> = {
+    [Name in EventNamesFromTransitions<M>]: {
+        event: Name;
+        target: EventTargetForName<M, Name>;
+        guard: boolean;
+        schema?: EventSchemaFor<M, Name>;
+    };
+}[EventNamesFromTransitions<M>];
+type BehaviorCallbackFor<M extends TypedModel<any, any, any, any, any, any, any, any>> = (ctx: Context, instance: M['__hsm_instance'] & Instance, event: EventOfName<M, EventNamesOf<M> & string>) => unknown;
+type OperationSignature<M extends TypedModel<any, any, any, any, any, any, any, any>, K extends keyof OperationsOf<M> & string> = Extract<OperationsOf<M>[K], (...args: any[]) => any>;
+type MachineInstanceFor<M extends TypedModel<any, any, any, any, any, any, any, Instance>, I extends Instance> = M extends TypedModel<infer A, infer O, any, any, any, any, any, any> ? Omit<I, "dispatch" | "state" | "takeSnapshot" | "get" | "set" | "call"> & {
+    __hsm_model: M;
+    dispatch(event: DispatchEventsOf<M>): void;
+    state(): StatePathsOf<M>;
+    takeSnapshot(): SnapshotOf<M>;
+    get<K extends keyof A & string>(name: K): A[K];
+    get(name: string): unknown;
+    set<K extends keyof A & string>(name: K, value: A[K]): void;
+    set(name: string, value: unknown): void;
+    call<K extends keyof O & string>(name: K, ...args: Parameters<Extract<O[K], (...args: any[]) => any>>): ReturnType<Extract<O[K], (...args: any[]) => any>>;
+    call(name: string, ...args: unknown[]): unknown;
+} : never;
+type FlattenGroupMember<Member> = Member extends Group<infer Members> ? FlattenGroupMembers<Members> : [Member];
+type FlattenGroupMembers<Members extends readonly unknown[]> = Members extends readonly [infer Head, ...infer Tail] ? [
+    ...FlattenGroupMember<Head>,
+    ...FlattenGroupMembers<Tail>
+] : [];
+type GroupModelOf<Member> = Member extends {
+    __hsm_model: infer Model;
+} ? Model extends TypedModel<any, any, any, any, any, any, any, any> ? Model : never : never;
+type GroupDispatchEventOf<Member> = GroupModelOf<Member> extends infer Model extends TypedModel<any, any, any, any, any, any, any, any> ? DispatchEventsOf<Model> : Member extends {
+    dispatch(event: infer Event): void;
+} ? Event : EventRecord;
+type GroupAttributeKeysOf<Member> = GroupModelOf<Member> extends infer Model extends TypedModel<any, any, any, any, any, any, any, any> ? AttributeKeysOf<Model> : string;
+type GroupAttributeValueOf<Member, Key extends string> = GroupModelOf<Member> extends infer Model extends TypedModel<any, any, any, any, any, any, any, any> ? Key extends AttributeKeysOf<Model> ? AttributesOf<Model>[Key] : never : unknown;
+type SharedAttributeKeysOfFlattenedMembers<Members extends readonly unknown[]> = Members extends readonly [infer Head, ...infer Tail] ? GroupAttributeKeysOf<Head> & SharedAttributeKeysOfFlattenedMembers<Tail> : string;
+type SharedAttributeKeysOfGroupMembers<Members extends readonly unknown[]> = SharedAttributeKeysOfFlattenedMembers<FlattenGroupMembers<Members>>;
+type SharedAttributeValueOfFlattenedMembers<Members extends readonly unknown[], Key extends string> = Members extends readonly [infer Head, ...infer Tail] ? GroupAttributeValueOf<Head, Key> & SharedAttributeValueOfFlattenedMembers<Tail, Key> : unknown;
+type SharedAttributeValueOfGroupMembers<Members extends readonly unknown[], Key extends string> = SharedAttributeValueOfFlattenedMembers<FlattenGroupMembers<Members>, Key>;
+type FirstGroupMember<Members extends readonly unknown[]> = FlattenGroupMembers<Members> extends readonly [infer Head, ...infer _Tail] ? Head : never;
+type GroupOperationKeysOf<Member> = GroupModelOf<Member> extends infer Model extends TypedModel<any, any, any, any, any, any, any, any> ? OperationKeysOf<Model> : string;
+type GroupOperationSignatureOf<Member, Key extends string> = GroupModelOf<Member> extends infer Model extends TypedModel<any, any, any, any, any, any, any, any> ? Key extends OperationKeysOf<Model> ? OperationSignature<Model, Key> : (...args: any[]) => unknown : (...args: any[]) => unknown;
+type GroupEventUnion<Members extends readonly unknown[]> = FlattenGroupMembers<Members>[number] extends infer Member ? Member extends unknown ? GroupDispatchEventOf<Member> : never : never;
+type GroupOperationKeys<Members extends readonly unknown[]> = GroupOperationKeysOf<FirstGroupMember<Members>>;
+type GroupOperationSignature<Members extends readonly unknown[], Key extends string> = GroupOperationSignatureOf<FirstGroupMember<Members>, Key>;
+type GroupSnapshotOfMember<Member> = GroupModelOf<Member> extends infer Model extends TypedModel<any, any, any, any, any, any, any, any> ? SnapshotOf<Model> : Member extends {
+    takeSnapshot(): infer CurrentSnapshot;
+} ? CurrentSnapshot : Snapshot;
+type GroupSnapshotsOfFlattenedMembers<Members extends readonly unknown[]> = Members extends readonly [infer Head, ...infer Tail] ? [
+    GroupSnapshotOfMember<Head>,
+    ...GroupSnapshotsOfFlattenedMembers<Tail>
+] : [];
+type GroupSnapshotOf<Members extends readonly unknown[]> = Snapshot & {
+    members: GroupSnapshotsOfFlattenedMembers<FlattenGroupMembers<Members>>;
+};
+type BuilderWithSpec<Signature, Spec> = Signature & {
+    readonly __hsmSpec: Spec;
+};
+type BehaviorArgument<EventType extends EventRecord = EventRecord> = ((ctx: Context, instance: Instance, evt: EventType) => unknown) | string;
+
+declare function join(...segments: string[]): string;
+declare function dirname(path: string): string;
+declare function isAbsolute(path: string): boolean;
+declare class Context {
+    listeners: Array<() => void>;
+    instances: Record<string, Instance>;
+    done: boolean;
+    constructor();
+    addEventListener(_type: "done", listener: () => void): void;
+    removeEventListener(_type: "done", listener: () => void): void;
+}
+declare const InitialEvent: {
+    kind: number;
+    qualifiedName: string;
+    name: string;
+};
+declare const FinalEvent: {
+    name: string;
+    kind: number;
+};
+declare const ErrorEvent: {
+    name: string;
+    kind: number;
+};
+declare const DefaultClock: Required<ClockConfig>;
+declare function event<Name extends string = string, Schema = unknown>(name: Name, schema?: Schema): Event<Name, Schema>;
+declare function apply(model: Model, stack: Array<AnyModelElement>, partials: ReadonlyArray<(model: Model, stack: Array<AnyModelElement>) => unknown>): void;
+declare function isAncestor(ancestor: string, descendant: string): boolean;
+declare function lca(a: string, b: string): string;
+type AfterBucket = "entered" | "exited" | "processed" | "dispatched" | "executed";
+declare class Queue {
+    front: EventRecord[];
+    back: Array<EventRecord | undefined>;
+    backHead: number;
+    len(): number;
+    pop(): EventRecord | undefined;
+    push(...events: EventRecord[]): void;
+}
+type InstanceConstructor = {
+    new (): Instance;
+    (this: Instance): void;
+    prototype: Instance;
+};
+interface Instance {
+    _hsm: HSM | null;
+    dispatch(event: EventRecord): void;
+    state(): string;
+    context(): Context;
+    clock(): Required<ClockConfig>;
+    get(name: string): unknown;
+    set(name: string, value: unknown): void;
+    call(name: string, ...args: unknown[]): unknown;
+    restart(data?: unknown): void;
+    takeSnapshot(): Snapshot;
+}
+declare const Instance: InstanceConstructor;
+declare class HSM {
+    static id: number;
+    private runtime;
+    private instance;
+    private ctx;
+    private model;
+    private currentState;
+    private queue;
+    private active;
+    private processing;
+    private id;
+    private name;
+    private attributes;
+    private historyShallow;
+    private historyDeep;
+    private after;
+    private clock;
+    private startData;
+    constructor(ctxOrInstance: Context | Instance, instanceOrModel: Model | Instance, maybeModelOrConfig: Model | Config | undefined, maybeConfig?: Config);
+    start(): this;
+    state(): string;
+    private resetAttributes;
+    private notify;
+    onAfter(bucket: AfterBucket, key: string, listener: () => void): void;
+    private get;
+    private set;
+    private call;
+    private invoke;
+    restart(data?: unknown): void;
+    private takeSnapshot;
+    private recordHistory;
+    private followHistoryDefault;
+    dispatch(event: EventRecord): void;
+    private process;
+    private transition;
+    private enter;
+    private exit;
+    private execute;
+    private terminate;
+    stop(): void;
+}
+declare function find(stack: AnyModelElement[], ...kindsToMatch: Kind[]): AnyModelElement | undefined;
+declare function start<M extends TypedModel<any, any, any, any, any, any, any, Instance>, ModelInstance extends NonNullable<M['__hsm_instance']> & Instance = NonNullable<M['__hsm_instance']> & Instance>(instance: ModelInstance, model: M, maybeConfig?: Config): MachineInstanceFor<M, ModelInstance>;
+declare function start<M extends TypedModel<any, any, any, any, any, any, any, Instance>, ModelInstance extends NonNullable<M['__hsm_instance']> & Instance = NonNullable<M['__hsm_instance']> & Instance>(ctx: Context, instance: ModelInstance, model: M, maybeConfig?: Config): MachineInstanceFor<M, ModelInstance>;
+declare function stop(instance: Instance): void;
+declare function state<Name extends string, const Parts extends readonly ModelElementSpec[] = readonly ModelElementSpec[]>(name: Name, ...partials: BuilderTuple<ValidateStateLocalSpecs<Parts>>): BuilderWithSpec<(model: Model, stack: AnyModelElement[]) => State, StateSpec<Name, Parts>>;
+declare function initial<const Clauses extends readonly TransitionBuilderClause[] = readonly TransitionBuilderClause[]>(...partials: TransitionBuilderTuple<Clauses>): BuilderWithSpec<(model: Model, stack: AnyModelElement[]) => Transition | undefined, InitialSpec<Clauses>>;
+declare function initial<Name extends string, const Clauses extends readonly TransitionBuilderClause[] = readonly TransitionBuilderClause[]>(name: Name, ...partials: TransitionBuilderTuple<Clauses>): BuilderWithSpec<(model: Model, stack: AnyModelElement[]) => Transition | undefined, InitialSpec<Clauses>>;
+declare function transition<const Clauses extends readonly TransitionBuilderClause[] = readonly TransitionBuilderClause[]>(...partials: TransitionBuilderTuple<Clauses>): BuilderWithSpec<(model: Model, stack: AnyModelElement[]) => Transition, TransitionSpec<Clauses>>;
+declare function source<Name extends string>(name: Name): BuilderWithSpec<(model: any, stack: any) => unknown, SourceClause<Name>>;
+declare function target<Name extends string>(name: Name): BuilderWithSpec<(model: any, stack: any) => unknown, TargetClause<Name>>;
+declare function on<Name extends string>(eventName: Name): BuilderWithSpec<(model: any, stack: any) => unknown, EventClause<Name, unknown>>;
+declare function on<Name extends string, Schema = unknown>(eventRecord: Event<Name, Schema>): BuilderWithSpec<(model: any, stack: any) => unknown, EventClause<Name, Schema>>;
+declare function onSet<Name extends string>(name: Name): BuilderWithSpec<(model: any, stack: any) => unknown, OnSetClause<Name>>;
+declare function onCall<Name extends string>(name: Name): BuilderWithSpec<(model: any, stack: any) => unknown, OnCallClause<Name>>;
+declare function when<Name extends string>(expr: Name): BuilderWithSpec<(model: Model, stack: AnyModelElement[]) => unknown, WhenClause<Name>>;
+declare function entry<EventType extends EventRecord = EventRecord, const Operations extends readonly BehaviorArgument<EventType>[] = readonly BehaviorArgument<EventType>[]>(...operations: Operations): BuilderWithSpec<(model: Model, stack: AnyModelElement[]) => State, EntrySpec<Operations>>;
+declare function exit<EventType extends EventRecord = EventRecord, const Operations extends readonly BehaviorArgument<EventType>[] = readonly BehaviorArgument<EventType>[]>(...operations: Operations): BuilderWithSpec<(model: Model, stack: AnyModelElement[]) => State, ExitSpec<Operations>>;
+declare function activity<EventType extends EventRecord = EventRecord, const Operations extends readonly BehaviorArgument<EventType>[] = readonly BehaviorArgument<EventType>[]>(...operations: Operations): BuilderWithSpec<(model: Model, stack: AnyModelElement[]) => State, ActivitySpec<Operations>>;
+declare function effect<const Operations extends readonly BehaviorArgument[]>(...operations: Operations): BuilderWithSpec<(model: Model, stack: AnyModelElement[]) => Transition, EffectClause<Operations>>;
+declare function guard<Name extends string>(expression: Name): BuilderWithSpec<(model: Model, stack: AnyModelElement[]) => unknown, GuardClause<Name>>;
+declare function guard<EventType extends EventRecord>(expression: (ctx: Context, instance: Instance, event: EventType) => boolean): GuardBuilder<EventType>;
+declare function attribute<Name extends string, Value = unknown>(name: Name, maybeDefault?: Value): BuilderWithSpec<(model: Model) => unknown, AttributeSpec<Name, Value>>;
+declare function operation<Name extends string, Fn extends Function>(name: Name, implementation: Fn): BuilderWithSpec<(model: Model) => unknown, OperationSpec<Name, Extract<Fn, (...args: any[]) => any>>>;
+declare function after<Name extends string>(duration: Name): BuilderWithSpec<(model: Model, stack: AnyModelElement[]) => unknown, AfterClause<Name>>;
+declare function after(duration: TimeExpression): BuilderWithSpec<(model: Model, stack: AnyModelElement[]) => unknown, AfterClause<TimeExpression>>;
+declare function every<Name extends string>(duration: Name): BuilderWithSpec<(model: Model, stack: AnyModelElement[]) => unknown, EveryClause<Name>>;
+declare function every(duration: TimeExpression): BuilderWithSpec<(model: Model, stack: AnyModelElement[]) => unknown, EveryClause<TimeExpression>>;
+declare function at<Name extends string>(timepoint: Name): BuilderWithSpec<(model: Model, stack: AnyModelElement[]) => unknown, AtClause<Name>>;
+declare function at(timepoint: ((ctx: Context, instance: Instance, evt: EventRecord) => number | Date | Promise<number> | Promise<Date>)): BuilderWithSpec<(model: Model, stack: AnyModelElement[]) => unknown, AtClause<TimeExpression>>;
+declare function defer<const EventNames extends readonly string[]>(...eventNames: EventNames): BuilderWithSpec<(model: Model, stack: AnyModelElement[]) => unknown, DeferSpec<EventNames>>;
+declare function final<Name extends string>(name: Name): BuilderWithSpec<(model: Model, stack: AnyModelElement[]) => {
+    qualifiedName: string;
+    kind: number;
+    entry: any[];
+    exit: any[];
+    activities: any[];
+    deferred: any[];
+    transitions: any[];
+    initial: any;
+}, FinalSpec<Name>>;
+declare function shallowHistory(elementOrName: string | ((...args: unknown[]) => unknown)): (model: Model, stack: AnyModelElement[]) => {
+    qualifiedName: string;
+    kind: number;
+    transitions: any[];
+};
+declare function deepHistory(elementOrName: string | ((...args: unknown[]) => unknown)): (model: Model, stack: AnyModelElement[]) => {
+    qualifiedName: string;
+    kind: number;
+    transitions: any[];
+};
+declare function choice(elementOrName: string | ((...args: unknown[]) => unknown)): (model: Model, stack: AnyModelElement[]) => {
+    qualifiedName: string;
+    kind: number;
+    transitions: any[];
+};
+declare function dispatchAll(ctx: Context, event: EventRecord): void;
+declare function define<RootName extends string, const Parts extends readonly ModelElementSpec[] = readonly ModelElementSpec[]>(name: RootName, ...partials: ValidatedModelElementBuilderTuple<Parts, Parts, Parts, `/${RootName}`>): TypedModelFromInfer<RootName, Parts>;
+declare function define<ModelSpec extends TypedModel<any, any, any, any, any, any, any, Instance> = never>(name: string, ...partials: [
+    ModelSpec
+] extends [never] ? never : Array<(model: Model, stack: AnyModelElement[]) => void>): ModelSpec;
+declare function dispatchTo(ctx: Context, event: EventRecord, ...ids: string[]): void;
+declare function get(ctxOrInstance: Context | Instance, maybeInstanceOrName: Instance | string, maybeName?: string): unknown;
+declare function set(ctxOrInstance: Context | Instance, maybeInstanceOrName: Instance | string, maybeNameOrValue: unknown, maybeValue?: unknown): void;
+declare function call(ctxOrInstance: Context | Instance, maybeInstanceOrName: Instance | string, maybeName: string, ...args: unknown[]): unknown;
+declare function restart(instance: Instance, data: unknown): void;
+declare function takeSnapshot(ctxOrInstance: Context | Instance, maybeInstance?: Instance): Snapshot;
+declare function afterProcess(ctx: Context, instance: Instance, maybeEvent?: EventRecord): Promise<void>;
+declare function afterDispatch(ctx: Context, instance: Instance, event: EventRecord): Promise<void>;
+declare function afterEntry(ctx: Context, instance: Instance, stateName: string): Promise<void>;
+declare function afterExit(ctx: Context, instance: Instance, stateName: string): Promise<void>;
+declare function afterExecuted(ctx: Context, instance: Instance, stateOrBehavior: string): Promise<void>;
+declare function id(instance: any): string;
+declare function qualifiedName(instance: any): any;
+declare function name(instance: any): string;
+declare function clock(instance: any): ClockConfig;
+declare class Group<Members extends readonly unknown[] = readonly Instance[]> {
+    instances: Instance[];
+    readonly __hsm_group_members?: Members;
+    constructor(...instances: unknown[]);
+    dispatch(event: GroupEventUnion<Members>): void;
+    set<K extends SharedAttributeKeysOfGroupMembers<Members>>(name: K, value: SharedAttributeValueOfGroupMembers<Members, K>): void;
+    call<K extends GroupOperationKeys<Members>>(name: K, ...args: Parameters<GroupOperationSignature<Members, K>>): ReturnType<GroupOperationSignature<Members, K>>;
+    stop(): void;
+    restart(data?: unknown): void;
+    takeSnapshot(): GroupSnapshotOf<Members>;
+    clock(): ClockConfig;
+}
+declare function makeGroup<const Members extends readonly unknown[]>(...instances: Members): Group<FlattenGroupMembers<Members>>;
+declare const NullKind: number;
+declare const ElementKind: number;
+declare const PartialKind: number;
+declare const VertexKind: number;
+declare const ConstraintKind: number;
+declare const BehaviorKind: number;
+declare const NamespaceKind: number;
+declare const ConcurrentKind: number;
+declare const SequentialKind: number;
+declare const StateMachineKind: number;
+declare const AttributeKind: number;
+declare const StateKind: number;
+declare const ModelKind: number;
+declare const TransitionKind: number;
+declare const InternalKind: number;
+declare const ExternalKind: number;
+declare const LocalKind: number;
+declare const SelfKind: number;
+declare const EventKind: number;
+declare const CompletionEventKind: number;
+declare const ChangeEventKind: number;
+declare const ErrorEventKind: number;
+declare const TimeEventKind: number;
+declare const CallEventKind: number;
+declare const PseudostateKind: number;
+declare const InitialKind: number;
+declare const FinalStateKind: number;
+declare const ChoiceKind: number;
+declare const JunctionKind: number;
+declare const DeepHistoryKind: number;
+declare const ShallowHistoryKind: number;
+declare const Define: typeof define;
+type State = Vertex & {
+    entry: Path[];
+    exit: Path[];
+    activities: Path[];
+    deferred: Path[];
+    initial?: Path;
+};
+declare const State: typeof state;
+declare const Final: typeof final;
+declare const ShallowHistory: typeof shallowHistory;
+declare const DeepHistory: typeof deepHistory;
+declare const Choice: typeof choice;
+type Transition = Element & {
+    guard: string;
+    events: string[];
+    effect: Path[];
+    source: Path;
+    target?: Path;
+    paths: Record<Path, TransitionPath>;
+};
+declare const Transition: typeof transition;
+declare const Initial: typeof initial;
+type Event<Name extends string = string, Data = unknown> = EventRecord & {
+    readonly name: Name;
+    readonly schema?: Data;
+};
+declare const Event: typeof event;
+declare const On: typeof on;
+declare const OnCall: typeof onCall;
+declare const OnSet: typeof onSet;
+declare const When: typeof when;
+declare const After: typeof after;
+declare const Every: typeof every;
+declare const At: typeof at;
+declare const Target: typeof target;
+declare const Source: typeof source;
+declare const Entry: typeof entry;
+declare const Exit: typeof exit;
+declare const Activity: typeof activity;
+declare const Effect: typeof effect;
+declare const Guard: typeof guard;
+declare const Defer: typeof defer;
+declare const Attribute: typeof attribute;
+type Operation = (ctx: Context, instance: Instance, event: EventRecord) => unknown;
+declare const Operation: typeof operation;
+declare const DispatchAll: typeof dispatchAll;
+declare const DispatchTo: typeof dispatchTo;
+declare const Get: typeof get;
+declare const Set: typeof set;
+declare const Call: typeof call;
+declare const Restart: typeof restart;
+declare const TakeSnapshot: typeof takeSnapshot;
+declare const MakeGroup: typeof makeGroup;
+declare const LCA: typeof lca;
+declare const IsAncestor: typeof isAncestor;
+declare const ID: typeof id;
+declare const QualifiedName: typeof qualifiedName;
+declare const Name: typeof name;
+declare const Clock: typeof clock;
+
+export { Activity, type ActivitySpec, After, type AfterClause, type AncestorsOf, At, type AtClause, Attribute, type AttributeKeysOf, AttributeKind, type AttributeSpec, type AttributesOf, type BehaviorCallbackFor, BehaviorKind, Call, CallEventKind, type CallableOperationKeysOf, type CanTransition, ChangeEventKind, type ChildrenOf, Choice, ChoiceKind, type ChoiceSpec, Clock, type ClockConfig, CompletionEventKind, type CompletionEventsOf, type CompletionStatePathsOf, ConcurrentKind, type Config, ConstraintKind, Context, DeepHistory, DeepHistoryKind, type DeepHistorySpec, DefaultClock, Defer, type DeferSpec, Define, type DescendantsOf, DispatchAll, type DispatchEvent, type DispatchEventOfName, type DispatchEventsOf, DispatchTo, type DoneEventNamesOf, type DoneEventOf, Effect, type EffectClause, ElementKind, Entry, type EntrySpec, ErrorEvent, ErrorEventKind, Event, type EventClause, EventKind, type EventNamesFromState, type EventNamesOf, type EventOfName, type EventSnapshotOf, type EventsForState, Every, type EveryClause, Exit, type ExitSpec, ExternalKind, Final, FinalEvent, type FinalSpec, FinalStateKind, type FinalStatesOf, Get, Group, type GroupSnapshotOf, Guard, type GuardClause, type GuardOperationKeysOf, ID, Initial, InitialEvent, InitialKind, type InitialSpec, type InitialStateOf, Instance, InternalKind, IsAncestor, type IsFinalState, JunctionKind, LCA, type LeafStatesOf, LocalKind, type MachineInstanceFor, MakeGroup, type ModelElementSpec, ModelKind, Name, NamespaceKind, NullKind, On, OnCall, type OnCallClause, OnSet, type OnSetClause, Operation, type OperationKeysOf, type OperationSpec, type OperationsOf, type ParentOf, PartialKind, PseudostateKind, QualifiedName, Queue, type RelativeStatePathsOf, Restart, SelfKind, SequentialKind, Set, ShallowHistory, ShallowHistoryKind, type ShallowHistorySpec, type Snapshot, type SnapshotOf, Source, type SourceClause, type SourcesForEvent, State, StateKind, StateMachineKind, type StatePathsOf, type StateSpec, TakeSnapshot, Target, type TargetClause, type TargetsFromState, type TargetsFromStateAndEvent, TimeEventKind, Transition, type TransitionBuilderClause, TransitionKind, type TransitionSpec, type TypedModel, VertexKind, When, type WhenClause, type WhenExprClause, activity, after, afterDispatch, afterEntry, afterExecuted, afterExit, afterProcess, apply, at, attribute, call, choice, clock, deepHistory, defer, define, dirname, dispatchAll, dispatchTo, effect, entry, event, every, exit, final, find, get, guard, id, initial, isAbsolute, isAncestor, join, lca, makeGroup, name, on, onCall, onSet, operation, qualifiedName, restart, set, shallowHistory, source, start, state, stop, takeSnapshot, target, transition, when };