@genesislcap/foundation-state-machine 14.70.0

package/README.md

@@ -0,0 +1,26 @@
+# Foundation State Machine
+
+[![lerna](https://img.shields.io/badge/maintained%20with-lerna-cc00ff.svg)](https://lerna.js.org/)
+[![TypeScript](https://img.shields.io/badge/%3C%2F%3E-TypeScript-%230074c1.svg)](https://www.typescriptlang.org/)
+
+State machines in `foundation-ui` are built upon the [xState](https://github.com/statelyai/xstate) v5+ library and provide bindable properties and other hooks. `foundation-state-machine` provides a collection of pre-built state machines and utilities to build your own machines.
+
+For details on how machines work see the API Docs and the v5+ version of the [xstate docs](https://stately.ai/docs/xstate-v5). 
+
+### [API Docs](./docs/api/index.md)
+
+### Pre-built state machines
+
+Overtime this package will provide a number of pre-built machines that offer common functionality. Visit their README files and API Docs for more information.
+
+* [FetchMachine](./src/machines/fetch/README.md)
+* ...
+
+Domain focused machines like `AuthMachine` will live in different packages.
+
+## License
+
+Note: this project provides front end dependencies and uses licensed components listed in the next section, thus licenses for those components are required during development. Contact [Genesis Global](https://genesis.global/contact-us/) for more details.
+
+### Licensed components
+Genesis low-code platform

package/dist/dts/core/actions.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Set error action.
+ * @remarks
+ * Used to set a top level error on the machine. This may equal to {@link @genesislcap/foundation-utils#ErrorMap} `lastError` in the `errors` property.
+ * @public
+ */
+export declare const setError: {
+    (_: import("xstate").ActionArgs<import("xstate").MachineContext, import("xstate").EventObject, import("xstate").ParameterizedObject>): void;
+    type: string;
+    assignment: import("xstate").Assigner<import("xstate").MachineContext, import("xstate").EventObject> | import("xstate").PropertyAssigner<import("xstate").MachineContext, import("xstate").EventObject>;
+    resolve: (actorContext: import("xstate").AnyActorContext, state: import("xstate").AnyState, actionArgs: import("xstate").ActionArgs<any, any, import("xstate").ParameterizedObject>, { assignment }: {
+        assignment: import("xstate").Assigner<any, any> | import("xstate").PropertyAssigner<any, any>;
+    }) => import("xstate").AnyState[];
+};
+/**
+ * Set error by key action.
+ * @remarks
+ * Used to set an error in the {@link @genesislcap/foundation-utils#ErrorMap} by key.
+ * @param key - The error key.
+ * @public
+ */
+export declare const setErrorByKey: (key: string) => {
+    (_: import("xstate").ActionArgs<import("xstate").MachineContext, import("xstate").EventObject, import("xstate").ParameterizedObject>): void;
+    type: string;
+    assignment: import("xstate").Assigner<import("xstate").MachineContext, import("xstate").EventObject> | import("xstate").PropertyAssigner<import("xstate").MachineContext, import("xstate").EventObject>;
+    resolve: (actorContext: import("xstate").AnyActorContext, state: import("xstate").AnyState, actionArgs: import("xstate").ActionArgs<any, any, import("xstate").ParameterizedObject>, { assignment }: {
+        assignment: import("xstate").Assigner<any, any> | import("xstate").PropertyAssigner<any, any>;
+    }) => import("xstate").AnyState[];
+};
+/**
+ * Escalate error action.
+ * @remarks
+ * Guard this call with a parent check to avoid warnings when there's no parent.
+ * @public
+ */
+export declare const escalateError: {
+    (_: import("xstate").ActionArgs<import("xstate").MachineContext, import("xstate").EventObject, import("xstate").ParameterizedObject>): void;
+    type: string;
+    to: string | import("xstate").AnyActorRef | ((args: import("xstate").UnifiedArg<import("xstate").MachineContext, import("xstate").EventObject>) => string | import("xstate").AnyActorRef);
+    event: any;
+    id: string;
+    delay: string | number | import("xstate").DelayExpr<import("xstate").MachineContext, import("xstate").EventObject>;
+    resolve: (actorContext: import("xstate").AnyActorContext, state: import("xstate").AnyState, args: import("xstate").ActionArgs<any, any, import("xstate").ParameterizedObject>, { to, event: eventOrExpr, id, delay }: {
+        to: string | import("xstate").AnyActorRef | ((args: import("xstate").UnifiedArg<import("xstate").MachineContext, import("xstate").EventObject>) => string | import("xstate").AnyActorRef);
+        event: import("xstate").EventObject | import("xstate").SendExpr<import("xstate").MachineContext, import("xstate").EventObject, import("xstate").EventObject>;
+        id: string;
+        delay: string | number | import("xstate").DelayExpr<import("xstate").MachineContext, import("xstate").EventObject>;
+    }) => (import("xstate").AnyState | {
+        to: import("xstate").AnyActorRef;
+        event: import("xstate").EventObject;
+        id: string;
+        delay: number;
+    })[];
+    execute: (actorContext: import("xstate").AnyActorContext, params: {
+        to: import("xstate").AnyActorRef;
+        event: import("xstate").EventObject;
+        id: string;
+        delay: number;
+    }) => void;
+};
+//# sourceMappingURL=actions.d.ts.map

package/dist/dts/core/actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../../src/core/actions.ts"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH,eAAO,MAAM,QAAQ;;;;;;;CAOnB,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,QAAS,MAAM;;;;;;;CASrC,CAAC;AAEL;;;;;GAKG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;CAGvB,CAAC"}

package/dist/dts/core/binding.d.ts

@@ -0,0 +1,37 @@
+import { BindingObserver, ExecutionContext } from '@microsoft/fast-element';
+/**
+ * @typeParam TReturn - The return type.
+ * @param value - The bound value.
+ * @param args - A binding observer.
+ * @internal
+ */
+export type SubscriberChangeCallback<TReturn = any> = (value: TReturn, args: BindingObserver) => void;
+/**
+ * @typeParam TTarget - The target interface.
+ * @typeParam TReturn - The return type.
+ * @param binding - A binding.
+ * @param args - A binding observer.
+ * @internal
+ */
+export type SubscriberChangeHandler<TTarget = any, TReturn = any> = (binding: (x?: TTarget, context?: ExecutionContext) => TReturn, args: BindingObserver) => void;
+/**
+ * @typeParam TTarget - The target interface.
+ * @typeParam TReturn - The return type.
+ * @internal
+ */
+export interface TargetSubscriber<TTarget = any, TReturn = any> {
+    handleChange: SubscriberChangeHandler<TTarget, TReturn>;
+}
+/**
+ * @typeParam TTarget - The target interface.
+ * @param target - The target.
+ * @internal
+ */
+export type TargetBinding<TTarget = any> = (target: TTarget) => any;
+/**
+ * @typeParam TTarget - The target interface.
+ * @param args - Binding args.
+ * @internal
+ */
+export declare const getBindArgs: <TTarget = any>(...args: unknown[]) => TargetBinding<TTarget>;
+//# sourceMappingURL=binding.d.ts.map

package/dist/dts/core/binding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binding.d.ts","sourceRoot":"","sources":["../../../src/core/binding.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAE5E;;;;;GAKG;AACH,MAAM,MAAM,wBAAwB,CAAC,OAAO,GAAG,GAAG,IAAI,CACpD,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,eAAe,KAClB,IAAI,CAAC;AAEV;;;;;;GAMG;AACH,MAAM,MAAM,uBAAuB,CAAC,OAAO,GAAG,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,CAClE,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,gBAAgB,KAAK,OAAO,EAC7D,IAAI,EAAE,eAAe,KAClB,IAAI,CAAC;AAEV;;;;GAIG;AACH,MAAM,WAAW,gBAAgB,CAAC,OAAO,GAAG,GAAG,EAAE,OAAO,GAAG,GAAG;IAC5D,YAAY,EAAE,uBAAuB,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;CACzD;AAED;;;;GAIG;AACH,MAAM,MAAM,aAAa,CAAC,OAAO,GAAG,GAAG,IAAI,CAAC,MAAM,EAAE,OAAO,KAAK,GAAG,CAAC;AAEpE;;;;GAIG;AACH,eAAO,MAAM,WAAW,2BAA4B,OAAO,EAAE,2BAS5D,CAAC"}

package/dist/dts/core/errors.d.ts

@@ -0,0 +1,41 @@
+import { Message } from '@genesislcap/foundation-comms';
+/**
+ * GenesisServerError.
+ * @remarks
+ * Represents an error received from a Genesis Server.
+ * @public
+ */
+export declare class GenesisServerError extends Error {
+    sent?: Message;
+    received?: Message;
+    constructor(sent?: Message, received?: Message, message?: string);
+    /**
+     * Capture known edge cases.
+     * @privateRemarks
+     * This is ugly, lets figure out if this is still an issue and remove if not.
+     */
+    isIgnorableError(): boolean;
+    getMessageError(): string;
+    getDetailsError(): string;
+    hasErrorCode(code: string): boolean;
+    private errorDetailFormatter;
+}
+/**
+ * @param error - An error.
+ * @public
+ */
+export declare const isGenesisServerError: (error: unknown) => boolean;
+/**
+ * MappingError.
+ * @public
+ */
+export declare class MappingError extends Error {
+    dto?: unknown;
+    constructor(dto?: unknown, message?: string);
+}
+/**
+ * @param error - An error.
+ * @public
+ */
+export declare const isMappingError: (error: unknown) => boolean;
+//# sourceMappingURL=errors.d.ts.map

package/dist/dts/core/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/core/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,+BAA+B,CAAC;AAExD;;;;;GAKG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;IAElC,IAAI,CAAC,EAAE,OAAO;IACd,QAAQ,CAAC,EAAE,OAAO;gBADlB,IAAI,CAAC,EAAE,OAAO,EACd,QAAQ,CAAC,EAAE,OAAO,EACzB,OAAO,GAAE,MAAwC;IAOnD;;;;OAIG;IACH,gBAAgB;IAUhB,eAAe;IAMf,eAAe,IAAI,MAAM;IAMzB,YAAY,CAAC,IAAI,EAAE,MAAM;IAMzB,OAAO,CAAC,oBAAoB;CAG7B;AAED;;;GAGG;AACH,eAAO,MAAM,oBAAoB,UAAW,OAAO,YAAwC,CAAC;AAE5F;;;GAGG;AACH,qBAAa,YAAa,SAAQ,KAAK;IAE5B,GAAG,CAAC,EAAE,OAAO;gBAAb,GAAG,CAAC,EAAE,OAAO,EACpB,OAAO,GAAE,MAAiC;CAM7C;AAED;;;GAGG;AACH,eAAO,MAAM,cAAc,UAAW,OAAO,YAAkC,CAAC"}

package/dist/dts/core/guards.d.ts

@@ -0,0 +1,67 @@
+import { DoneInvokeEvent, ErrorEvent, EventObject } from 'xstate';
+/**
+ * assertEvent.
+ * @privateRemarks
+ * Note `asserts` need to be functions to work.
+ * @param event - An event.
+ * @param type - An event type.
+ * @public
+ */
+export declare function assertEvent<TEvent extends EventObject = EventObject>(event: TEvent, type: TEvent['type']): asserts event is Extract<TEvent, {
+    type: TEvent['type'];
+}>;
+/**
+ * isDoneInvokeEvent.
+ * @param event - An event.
+ * @public
+ */
+export declare const isDoneInvokeEvent: <TData = any>(event: EventObject | DoneInvokeEvent<TData>) => event is DoneInvokeEvent<TData>;
+/**
+ * isErrorEvent.
+ * @param event - An event.
+ * @public
+ */
+export declare const isErrorEvent: <TData = any>(event: EventObject | ErrorEvent<TData>) => event is ErrorEvent<TData>;
+/**
+ * isErrorCustomEvent.
+ * @remarks
+ * What `escalate` from a child is typed as.
+ * @param event - An event.
+ * @public
+ */
+export declare const isErrorCustomEvent: <TData = any>(event: EventObject | ErrorEvent<TData>) => event is ErrorEvent<TData>;
+/**
+ * isActorErrorEvent.
+ * @param actorId - An actor id.
+ * @param event - An event.
+ * @public
+ */
+export declare const isActorErrorEvent: <TData = any>(actorId: string, event: EventObject | ErrorEvent<TData>) => event is ErrorEvent<TData>;
+/**
+ * isErrorType.
+ * @param type - An event type.
+ * @public
+ */
+export declare const isErrorType: <TType extends ErrorConstructor>(type: TType) => (event: any) => boolean;
+/**
+ * isTypeError.
+ * @public
+ */
+export declare const isTypeError: ({ event }: {
+    event: any;
+}) => boolean;
+/**
+ * isSyntaxError.
+ * @public
+ */
+export declare const isSyntaxError: ({ event }: {
+    event: any;
+}) => boolean;
+/**
+ * isAbortError.
+ * @public
+ */
+export declare const isAbortError: ({ event }: {
+    event: any;
+}) => boolean;
+//# sourceMappingURL=guards.d.ts.map

package/dist/dts/core/guards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guards.d.ts","sourceRoot":"","sources":["../../../src/core/guards.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAElE;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,MAAM,SAAS,WAAW,GAAG,WAAW,EAClE,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,GACnB,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,CAAA;CAAE,CAAC,CAI5D;AAED;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,+FAEuC,CAAC;AAEtE;;;;GAIG;AACH,eAAO,MAAM,YAAY,qFAE0C,CAAC;AAEpE;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,qFAEkC,CAAC;AAElE;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,yBACnB,MAAM,uEAE8E,CAAC;AAEhG;;;;GAIG;AACH,eAAO,MAAM,WAAW,0EAOrB,CAAC;AAEJ;;;GAGG;AACH,eAAO,MAAM,WAAW;;aAA+C,CAAC;AAExE;;;GAGG;AACH,eAAO,MAAM,aAAa;;aAAiD,CAAC;AAE5E;;;GAGG;AACH,eAAO,MAAM,YAAY;;aAQxB,CAAC"}

package/dist/dts/core/index.d.ts

@@ -0,0 +1,8 @@
+export * from './actions';
+export * from './binding';
+export * from './errors';
+export * from './guards';
+export * from './inputs';
+export * from './machine';
+export * from './state';
+//# sourceMappingURL=index.d.ts.map

package/dist/dts/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC"}

package/dist/dts/core/inputs.d.ts

@@ -0,0 +1,19 @@
+import { ErrorDetailMap, ErrorMap } from '@genesislcap/foundation-utils';
+/**
+ * ErrorWorkflowInput type.
+ * @public
+ */
+export type ErrorWorkflowInput = {
+    errorKey: string;
+    errorValue: any;
+    errorMap: ErrorMap<ErrorDetailMap>;
+};
+/**
+ * Error workflow input.
+ * @param key - An error key.
+ * @public
+ */
+export declare const errorWorkflowInput: (key: string) => ({ context }: {
+    context: any;
+}) => ErrorWorkflowInput;
+//# sourceMappingURL=inputs.d.ts.map

package/dist/dts/core/inputs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inputs.d.ts","sourceRoot":"","sources":["../../../src/core/inputs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AAEzE;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,GAAG,CAAC;IAChB,QAAQ,EAAE,QAAQ,CAAC,cAAc,CAAC,CAAC;CACpC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,QACvB,MAAM;;MACG,kBAIb,CAAC"}

package/dist/dts/core/machine.d.ts

@@ -0,0 +1,338 @@
+import { ErrorDetailMap, ErrorMap } from '@genesislcap/foundation-utils';
+import { BindingObserver, ExecutionContext } from '@microsoft/fast-element';
+import { Container } from '@microsoft/fast-foundation';
+import type { AnyEventObject, EventObject, InternalMachineImplementations, InterpreterFrom, InterpreterOptions, MachineContext as XMachineContext, NoInfer, ParameterizedObject, ProvidedActor, ResolveTypegenMeta, StateMachine, StateValue, StateValueFrom, TypegenDisabled } from 'xstate';
+import { SubscriberChangeCallback } from './binding';
+/**
+ * MachineContext interface.
+ *
+ * @remarks
+ * The interface of our xstate based machine contexts that include `error` and `errors` properties. Should be extended.
+ *
+ * @example Creating a machine context.
+ * ```ts
+ * export interface MyMachineContext extends MachineContext {
+ *   ...
+ * };
+ * ```
+ *
+ * @public
+ */
+export interface MachineContext extends XMachineContext {
+    /**
+     * A `ErrorMap` of errors that may have occurred during the machine's workflows.
+     */
+    readonly errors: ErrorMap<ErrorDetailMap>;
+    /**
+     * A general machine error. Maybe equal to `errors.lastError`.
+     */
+    readonly error: any;
+}
+/**
+ * Machine interface.
+ *
+ * @remarks
+ * The interface of our xstate based machines or logic workflows. These contain bindable properties for convenience.
+ * Should be extended.
+ *
+ * @example Creating a machine in the DI.
+ * ```ts
+ * export interface MyMachine extends Machine<MyMachineContext, MyMachineEvent> {
+ *   readonly service: MyService;
+ *   ...
+ * }
+ * export class DefaultMyMachine
+ *   extends AbstractMachine<MyMachineContext, MyMachineEvent>
+ *   implements MyMachine
+ * {
+ *   constructor(@MyService readonly service: MyService) {
+ *     super();
+ *     this.machine = createMachine<MyMachineContext, MyMachineEvent>(...);
+ *     this.start(); // < Call now or later to ready the machine.
+ *   }
+ *   start(
+ *     options: InterpreterOptions<typeof this.machine> = {
+ *       input: myDefaultContext,
+ *     },
+ *   ) {
+ *     super.start(options);
+ *   }
+ * }
+ * // Whether the machine should be `transient` or a `singleton` probably depends on the use case and if it contains a `final` state.
+ * export const MyMachine = DI.createInterface<MyMachine>((x) => x.transient(DefaultMyMachine));
+ * ```
+ *
+ * Machines are bindable from templates and other logic.
+ *
+ * @example Surface errors in a template.
+ * ```ts
+ * ${when(
+ *   (x) => !!x.myMachine.errors.size,
+ *   html<MyComponent>`
+ *     <span>${(x) => x.myMachine.errors.messages}</span>
+ *   `,
+ * )}
+ * ```
+ *
+ * @example Use context data in a class.
+ * ```ts
+ * this.myMachine.binding((x) => x.context.data, (value) => {
+ *   // use data
+ * });
+ * ```
+ *
+ * @public
+ */
+export interface Machine<TContext extends MachineContext, TEvent extends EventObject = AnyEventObject, TAction extends ParameterizedObject = ParameterizedObject, TActor extends ProvidedActor = ProvidedActor, TInput = any, TResolvedTypesMeta = ResolveTypegenMeta<TypegenDisabled, NoInfer<TEvent>, TAction, TActor>> {
+    /**
+     * Mandatory machine property.
+     * @remarks
+     * The logic / config that goes into a machine is not accessible from the outside, and is owned by the implementing
+     * class. However, consumers of that may provide custom `implementations` in the xstate sense via the `provide()` api.
+     */
+    readonly machine: StateMachine<TContext, TEvent, TAction, TActor, TInput, TResolvedTypesMeta>;
+    /**
+     * Optional actor
+     * @remarks
+     * Callers can decide to reuse/reference if set or create their own.
+     */
+    readonly actor?: InterpreterFrom<StateMachine<TContext, TEvent, TAction, TActor, TInput, TResolvedTypesMeta>>;
+    /**
+     * The current `state` of the machine itself. This is not to be confused with state in the data or store sense.
+     */
+    readonly state: StateValue;
+    /**
+     * The `state` of the machine when started. Allows consumers to start a machine from a persisted state.
+     */
+    readonly startingState: StateValue;
+    /**
+     * The current `context` of the machine. The data points in context may be considered transient in nature.
+     *
+     * @privateRemarks
+     * Review the possibility of using an object with `@observable` properties as `context`, such as a store fragment or class.
+     */
+    readonly context: Partial<TContext>;
+    /**
+     * The `context` of the machine when started.
+     */
+    readonly startingContext: Partial<TContext>;
+    /**
+     * Indicates if the machine has completed the happy path.
+     */
+    readonly complete: boolean;
+    /**
+     * Holds successful machine output if any.
+     */
+    readonly output: any;
+    /**
+     * An {@link @genesislcap/foundation-utils#ErrorMap | ErrorMap} of errors that may have occurred during the machine's workflows.
+     */
+    readonly errors: ErrorMap<ErrorDetailMap>;
+    /**
+     * A general machine error. Likely equal to `errors.lastError`.
+     */
+    readonly error: any;
+    /**
+     * Start the machine.
+     *
+     * @remarks
+     * Called to ready the machine and create the internal actor (interpreter). This is called internally after
+     * `createMachine` by convention, however it should also be called after calling {@link Machine.provide | provide}
+     * when overriding logic. Calling `start` on an injected machine allows you to restart/reuse it if needed. This is okay
+     * for machines registered as `transient` in the DI, but care should be taken when creating a machine registered as a
+     * `singleton`. You may need to check the status of the machine and block re-starts.
+     *
+     * @param options - Optional InterpreterOptions. Can be used to restore to a previously persisted state.
+     */
+    start(options?: InterpreterOptions<StateMachine<TContext, TEvent, TAction, TActor, TInput, TResolvedTypesMeta>>): any;
+    /**
+     * Stop the machine.
+     */
+    stop(): void;
+    /**
+     * Recreate the internal machine with the provided implementations.
+     *
+     * @example Using an existing machine with a custom implementation.
+     * ```ts
+     * @MyMachine readonly machine: MyMachine;
+     * ...
+     * this.machine.provide({
+     *   actors: {
+     *     serviceCallX: fromPromise(async ({ input }) => Promise.resolve(new Error('Overridden serviceCallX'))),
+     *     onSuccess: (context) => successHandlerInHost(context.data)
+     *   },
+     *   guards: {
+     *     isAssured: ({ context }) => true,
+     *   },
+     * });
+     * // When you change the machine it will stop if running, so you'll have to call {@link Machine.start | start} again.
+     * this.machine.start();
+     * ```
+     *
+     * @param implementations - `actions`, `guards`, `actors`... to merge with existing options.
+     */
+    provide(implementations: InternalMachineImplementations<TContext, TEvent, TAction, TActor, TResolvedTypesMeta, true>): void;
+    /**
+     * Check `state` matches provided value.
+     *
+     * @remarks
+     * Can be useful if you need to conditionally run logic or render markup.
+     *
+     * @example
+     * ```ts
+     * if (machine.matches('inactive')) { ... }
+     * ```
+     *
+     * @param value - A state value.
+     */
+    matches(value: StateValueFrom<StateMachine<TContext, TEvent, TAction, TActor, TInput, TResolvedTypesMeta>>): boolean;
+    /**
+     * Check `tags` contain provided tag.
+     *
+     * @remarks
+     * This differs from `matches`, as multiple states may use common tags such as `pending` to indicate some async work
+     * is occurring. As with `matches`, `hasTag` can be useful if you need to conditionally run logic or render markup.
+     *
+     * @example
+     * ```ts
+     * if (machine.hasTag('pending')) { ... }
+     * ```
+     *
+     * @param tag - A tag.
+     */
+    hasTag(tag: string): boolean;
+    /**
+     * An api to send events to the machine.
+     *
+     * @param event - An event.
+     */
+    send(event: TEvent): void;
+    /**
+     * A custom event handler to send events to the machine.
+     *
+     * @param event - A custom event.
+     */
+    onSendEvent(event: CustomEvent<TEvent>): void;
+    /**
+     * An api to allow the observation of values and arbitrary bindings outside the template engine.
+     *
+     * @example
+     * TS attains the value type information from the machine's interface.
+     * ```ts
+     * this.myMachine.binding(x => x.context.data, value => {...}); // value is typeof data
+     * ```
+     *
+     * @example
+     * You can also use the underlying BindingObserver api should you prefer.
+     * ```ts
+     * this.myMachine.binding(x => x.error).subscribe({
+     *   handleChange(binding, args) {
+     *     ...
+     *   }
+     * })
+     * ```
+     *
+     * @param token - A target lookup token which can take various forms.
+     * @param subscriberChangeCallback - {@link SubscriberChangeCallback}.
+     * @param isVolatileBinding - Indicates the binding is volatile.
+     * @param context - {@link @microsoft/fast-element#ExecutionContext}.
+     *
+     * @public
+     */
+    binding<TReturn = any, TParent = any>(token: ((target: this) => TReturn) | keyof this, subscriberChangeCallback?: SubscriberChangeCallback<TReturn> | undefined, isVolatileBinding?: boolean, context?: ExecutionContext): BindingObserver<this, TReturn, TParent>;
+    /**
+     * Gets the machine from the container.
+     *
+     * @remarks
+     * Calling `getFromContainer` on an injected machine will return a new instance providing it was registered with the
+     * DI as `transient`. This is simply a convenience method, and may be useful as some machines contain 'final' states,
+     * meaning once they complete they can no longer receive events. However, if you want to continue to work with your
+     * injected machine reference, re-calling {@link Machine.start | start} may also be a viable option.
+     *
+     * Please note that machines are injected into other machines to form parts of complex workflows. In such cases,
+     * the parent machine will `invoke` or `spawn` the injected machine's `logic` directly to always create a new actor.
+     *
+     * @example Invoke an injected machine's `logic` from a parent machine
+     * ```ts
+     * invoke: {
+     *    id: 'dataFetcher',
+     *    src: fetchMachine.machine, // < Or `src: 'fetcher'`, and create that actor to interact with the injected machine.
+     *    ...
+     * }
+     * ```
+     */
+    getFromContainer(): this;
+}
+/**
+ * AbstractMachine base class.
+ * @public
+ */
+export declare abstract class AbstractMachine<TContext extends MachineContext, TEvent extends EventObject = AnyEventObject, TAction extends ParameterizedObject = ParameterizedObject, TActor extends ProvidedActor = ProvidedActor, TInput = any, TResolvedTypesMeta = ResolveTypegenMeta<TypegenDisabled, NoInfer<TEvent>, TAction, TActor>> implements Machine<TContext, TEvent, TAction, TActor, TInput, TResolvedTypesMeta> {
+    /**
+     * @internal
+     */
+    protected container: Container;
+    /** {@inheritDoc Machine.machine} */
+    machine: StateMachine<TContext, TEvent, TAction, TActor, TInput, TResolvedTypesMeta>;
+    /** {@inheritDoc Machine.actor} */
+    actor: InterpreterFrom<StateMachine<TContext, TEvent, TAction, TActor, TInput, TResolvedTypesMeta>>;
+    /** {@inheritDoc Machine.state} */
+    state: StateValue;
+    /** {@inheritDoc Machine.startingState} */
+    startingState: StateValue;
+    /** {@inheritDoc Machine.context} */
+    context: Partial<TContext>;
+    /** {@inheritDoc Machine.startingContext} */
+    startingContext: Partial<TContext>;
+    /** {@inheritDoc Machine.complete} */
+    complete: boolean;
+    /** {@inheritDoc Machine.output} */
+    output: any;
+    /** {@inheritDoc Machine.errors} */
+    errors: ErrorMap<ErrorDetailMap>;
+    /** {@inheritDoc Machine.error} */
+    error: any;
+    /**
+     * @internal
+     */
+    private subscription;
+    /** {@inheritDoc Machine.start} */
+    start(options?: InterpreterOptions<typeof this.machine>): void;
+    /** {@inheritDoc Machine.stop} */
+    stop(): void;
+    /**
+     * @internal
+     */
+    protected interpret(options?: InterpreterOptions<typeof this.machine>): void;
+    /**
+     * @internal
+     */
+    protected subscribe(): void;
+    /**
+     * @internal
+     */
+    protected unsubscribe(): void;
+    /**
+     * @internal
+     */
+    protected startActor(): void;
+    /**
+     * @internal
+     */
+    protected stopActor(): void;
+    /** {@inheritDoc Machine.provide} */
+    provide(implementations: InternalMachineImplementations<TContext, TEvent, TAction, TActor, TResolvedTypesMeta, true>): void;
+    /** {@inheritDoc Machine.matches} */
+    matches(value: StateValueFrom<typeof this.machine>): boolean;
+    /** {@inheritDoc Machine.hasTag} */
+    hasTag(tag: string): boolean;
+    /** {@inheritDoc Machine.send} */
+    send(event: TEvent): void;
+    /** {@inheritDoc Machine.onSendEvent} */
+    onSendEvent: (event: CustomEvent<TEvent>) => void;
+    /** {@inheritDoc Machine.binding} */
+    binding<TReturn = any, TParent = any>(token: ((target: this) => TReturn) | keyof this, subscriberChangeCallback?: SubscriberChangeCallback<TReturn> | undefined, isVolatileBinding?: boolean, context?: ExecutionContext): BindingObserver<this, TReturn, TParent>;
+    /** {@inheritDoc Machine.getFromContainer} */
+    abstract getFromContainer(): this;
+}
+//# sourceMappingURL=machine.d.ts.map

package/dist/dts/core/machine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"machine.d.ts","sourceRoot":"","sources":["../../../src/core/machine.ts"],"names":[],"mappings":"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"}

package/dist/dts/core/state.d.ts

@@ -0,0 +1,11 @@
+import type { StateNodeConfig } from 'xstate';
+/**
+ * Creates an error state node.
+ *
+ * @param key - An error state key.
+ * @param metaContent - An optional meta content value.
+ * @param final - An optional flag which adds final with output functionality.
+ * @public
+ */
+export declare const createErrorStateNode: (key: string, metaContent?: string, final?: boolean) => StateNodeConfig<any, any, any, any>;
+//# sourceMappingURL=state.d.ts.map

package/dist/dts/core/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../src/core/state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAC;AAG9C;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,QAC1B,MAAM,gBACG,MAAM,UACb,OAAO,KACb,gBAAgB,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAgBpC,CAAC"}

package/dist/dts/index.d.ts

@@ -0,0 +1,4 @@
+export * from './core';
+export * from './machines';
+export * from './utils';
+//# sourceMappingURL=index.d.ts.map

package/dist/dts/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC"}