@genesislcap/foundation-state-machine 14.70.0

package/dist/foundation-state-machine.d.ts

@@ -0,0 +1,884 @@
+/// <reference types="webappsec-credential-management" />
+
+import { ActionArgs } from 'xstate';
+import { AnyActorContext } from 'xstate';
+import { AnyActorRef } from 'xstate';
+import type { AnyEventObject } from 'xstate';
+import { AnyState } from 'xstate';
+import { Assigner } from 'xstate';
+import { BindingObserver } from '@microsoft/fast-element';
+import { Container } from '@microsoft/fast-foundation';
+import { DelayExpr } from 'xstate';
+import { DoneInvokeEvent } from 'xstate';
+import { ErrorDetailMap } from '@genesislcap/foundation-utils';
+import { ErrorEvent as ErrorEvent_2 } from 'xstate';
+import { ErrorMap } from '@genesislcap/foundation-utils';
+import { EventObject } from 'xstate';
+import { ExecutionContext } from '@microsoft/fast-element';
+import type { IBackoffFactory } from 'cockatiel';
+import { ICancellationContext } from 'cockatiel';
+import { IMergedPolicy } from 'cockatiel';
+import { InterfaceSymbol } from '@microsoft/fast-foundation';
+import type { InternalMachineImplementations } from 'xstate';
+import type { InterpreterFrom } from 'xstate';
+import type { InterpreterOptions } from 'xstate';
+import type { IRetryBackoffContext } from 'cockatiel';
+import { IRetryContext } from 'cockatiel';
+import { Logger } from '@genesislcap/foundation-utils';
+import { MachineContext as MachineContext_2 } from 'xstate';
+import { Message } from '@genesislcap/foundation-comms';
+import type { NoInfer } from 'xstate';
+import { ParameterizedObject } from 'xstate';
+import { PropertyAssigner } from 'xstate';
+import type { ProvidedActor } from 'xstate';
+import type { ResolveTypegenMeta } from 'xstate';
+import { RetryPolicy } from 'cockatiel';
+import { SendExpr } from 'xstate';
+import type { StateMachine } from 'xstate';
+import type { StateNodeConfig } from 'xstate';
+import type { StateValue } from 'xstate';
+import type { StateValueFrom } from 'xstate';
+import { StatusCodes } from 'http-status-codes';
+import { TimeoutPolicy } from 'cockatiel';
+import type { TypegenDisabled } from 'xstate';
+import { UnifiedArg } from 'xstate';
+
+/**
+ * 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 AbstractMachine.machine>): void;
+    /** {@inheritDoc Machine.stop} */
+    stop(): void;
+    /**
+     * @internal
+     */
+    protected interpret(options?: InterpreterOptions<typeof AbstractMachine.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 AbstractMachine.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;
+}
+
+/**
+ * APIError.
+ * @remarks
+ * Bad server `Response`.
+ * @public
+ */
+export declare class APIError extends Error {
+    status: number;
+    data?: unknown;
+    constructor(status: number, data?: unknown, message?: string);
+}
+
+/**
+ * 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'];
+}>;
+
+/**
+ * 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>;
+
+/**
+ * A fetch policy factory.
+ * @remarks
+ * Will retry network errors and responses with certain status codes up to the specified max attempts.
+ * @param maxAttempts - Max attempts. Defaults to `2`.
+ * @param retryCodes - Status code array to retry. Defaults to {@link defaultRetryStatsCodes}.
+ * @param backoff - Backoff algo. Defaults to {@link cockatiel#ExponentialBackoff}.
+ * @param timeoutDuration - Timeout duration. Defaults to 3 seconds.
+ * @param logEvents - Log events to the console. Defaults to `true`.
+ * @public
+ */
+export declare const createFetchPolicy: (maxAttempts?: number, retryCodes?: StatusCodes[] | number[], backoff?: IBackoffFactory<IRetryBackoffContext<unknown>>, timeoutDuration?: number, logEvents?: boolean) => IMergedPolicy<IRetryContext & ICancellationContext, never, [RetryPolicy, TimeoutPolicy]>;
+
+/**
+ * Creates an extractor that applies a deserializer to the extracted response data.
+ * @param deserializer - The deserializer to apply.
+ * @param extractor - An optional data extractor. Defaults to {@link defaultResponseDataExtractor}.
+ * @public
+ */
+export declare const createResponseDataExtractorWithDeserializer: <TInput = any, TOutput = any>(deserializer: (data: TInput) => Promise<TOutput>, extractor?: ResponseDataExtractor) => ResponseDataExtractor;
+
+/**
+ * The default fetch config.
+ * @public
+ */
+export declare const defaultFetchConfig: FetchConfig;
+
+/**
+ * Default FetchMachine.
+ * @public
+ */
+export declare class DefaultFetchMachine extends AbstractMachine<FetchMachineContext, FetchMachineEvent> implements FetchMachine {
+    private config;
+    constructor(config?: FetchConfig);
+    /** {@inheritDoc Machine.start} */
+    start(options?: InterpreterOptions<typeof DefaultFetchMachine.machine>): void;
+    /** {@inheritDoc Machine.getFromContainer} */
+    getFromContainer(): this;
+}
+
+/**
+ * Default FetchMachineContext.
+ * @public
+ */
+export declare const defaultFetchMachineContext: Partial<FetchMachineContext>;
+
+/**
+ * The default fetch policy.
+ * @public
+ */
+export declare const defaultFetchPolicy: IMergedPolicy<IRetryContext & ICancellationContext, never, [RetryPolicy, TimeoutPolicy]>;
+
+/**
+ * {@inheritDoc ResponseDataExtractor}
+ * @public
+ */
+export declare const defaultResponseDataExtractor: ResponseDataExtractor;
+
+/**
+ * {@inheritDoc ResponseOkChecker}
+ * @public
+ */
+export declare const defaultResponseOkChecker: ResponseOkChecker;
+
+/**
+ * Default retry stats codes.
+ * @public
+ */
+export declare const defaultRetryStatsCodes: StatusCodes[];
+
+/**
+ * ErrorWorkflowInput type.
+ * @public
+ */
+export declare 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;
+
+/**
+ * Escalate error action.
+ * @remarks
+ * Guard this call with a parent check to avoid warnings when there's no parent.
+ * @public
+ */
+export declare const escalateError: {
+    (_: ActionArgs<MachineContext_2, EventObject, ParameterizedObject>): void;
+    type: string;
+    to: string | AnyActorRef | ((args: UnifiedArg<MachineContext_2, EventObject>) => string | AnyActorRef);
+    event: any;
+    id: string;
+    delay: string | number | DelayExpr<MachineContext_2, EventObject>;
+    resolve: (actorContext: AnyActorContext, state: AnyState, args: ActionArgs<any, any, ParameterizedObject>, { to, event: eventOrExpr, id, delay }: {
+        to: string | AnyActorRef | ((args: UnifiedArg<MachineContext_2, EventObject>) => string | AnyActorRef);
+        event: EventObject | SendExpr<MachineContext_2, EventObject, EventObject>;
+        id: string;
+        delay: string | number | DelayExpr<MachineContext_2, EventObject>;
+    }) => (AnyState | {
+        to: AnyActorRef;
+        event: EventObject;
+        id: string;
+        delay: number;
+    })[];
+    execute: (actorContext: AnyActorContext, params: {
+        to: AnyActorRef;
+        event: EventObject;
+        id: string;
+        delay: number;
+    }) => void;
+};
+
+/**
+ * FetchConfig interface.
+ * @public
+ */
+export declare interface FetchConfig {
+    /**
+     * Defaults to {@link typescript#fetch}.
+     * @privateRemarks
+     * This config property allows us to mock {@link typescript#Response | responses} during testing.
+     */
+    fetcher: typeof fetch;
+    /**
+     * Defaults to {@link defaultFetchPolicy}
+     */
+    fetchPolicy?: IMergedPolicy<any, any, any>;
+    /**
+     * Defaults to {@link defaultResponseOkChecker}
+     */
+    responseOkChecker?: ResponseOkChecker;
+    /**
+     * Defaults to {@link defaultResponseDataExtractor}
+     */
+    responseDataExtractor?: ResponseDataExtractor;
+}
+
+/**
+ * FetchConfig DI key.
+ * @internal
+ */
+export declare const FetchConfig: InterfaceSymbol<FetchConfig>;
+
+/**
+ * FetchMachine interface.
+ * @public
+ */
+export declare interface FetchMachine extends Machine<FetchMachineContext, FetchMachineEvent> {
+}
+
+/**
+ * FetchMachine DI key.
+ * @internal
+ */
+export declare const FetchMachine: InterfaceSymbol<FetchMachine>;
+
+/**
+ * FetchMachineContext interface.
+ * @remarks
+ * Transient state during the machine's execution.
+ * @public
+ */
+export declare interface FetchMachineContext extends MachineContext {
+    /**
+     * The params of the fetch request.
+     */
+    params: {
+        url: string;
+        /**
+         * See {@link typescript#RequestInit} or {@link typescript#CMRequestInit}.
+         */
+        requestInit?: RequestInit | CMRequestInit;
+        /**
+         * Individual fetch requests can provide fetch config overrides when necessary.
+         */
+        fetchConfig?: FetchConfig;
+    };
+    /**
+     * The abort controller of the fetch request.
+     */
+    controller: AbortController;
+    /**
+     * The fetch response.
+     */
+    response: Response | undefined;
+    /**
+     * The extracted response data.
+     */
+    data: any;
+}
+
+/**
+ * FetchMachineEvent type.
+ * @remarks
+ * The send action events used to invoke the machine.
+ * @public
+ */
+export declare type FetchMachineEvent = {
+    type: 'fetch';
+    params: FetchMachineContext['params'];
+} | {
+    type: 'cancel';
+} | DoneInvokeEvent<unknown> | ErrorEvent_2<unknown>;
+
+/**
+ * FetchMachineEventMap type.
+ * @remarks
+ * The mediation CustomEvent used to invoke machine actions.
+ * @public
+ */
+export declare type FetchMachineEventMap = {
+    'fetch-machine-event': FetchMachineEvent;
+};
+
+/**
+ * FetchMachineOutput type.
+ * @remarks
+ * The output of the machine when it reaches it's final state, which is provided to host machines via handlers.
+ * @public
+ */
+export declare type FetchMachineOutput<TData = any> = Partial<Pick<FetchMachineContext, 'response' | 'error'>> & {
+    data: TData;
+};
+
+/**
+ * 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;
+}
+
+/**
+ * @typeParam TTarget - The target interface.
+ * @param args - Binding args.
+ * @internal
+ */
+export declare const getBindArgs: <TTarget = any>(...args: unknown[]) => TargetBinding<TTarget>;
+
+/**
+ * isAbortError.
+ * @public
+ */
+export declare const isAbortError: ({ event }: {
+    event: any;
+}) => boolean;
+
+/**
+ * isActorErrorEvent.
+ * @param actorId - An actor id.
+ * @param event - An event.
+ * @public
+ */
+export declare const isActorErrorEvent: <TData = any>(actorId: string, event: EventObject | ErrorEvent_2<TData>) => event is ErrorEvent_2<TData>;
+
+/**
+ * @param error - An error.
+ * @public
+ */
+export declare const isAPIError: (error: unknown) => boolean;
+
+/**
+ * isDoneInvokeEvent.
+ * @param event - An event.
+ * @public
+ */
+export declare const isDoneInvokeEvent: <TData = any>(event: EventObject | DoneInvokeEvent<TData>) => event is DoneInvokeEvent<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_2<TData>) => event is ErrorEvent_2<TData>;
+
+/**
+ * isErrorEvent.
+ * @param event - An event.
+ * @public
+ */
+export declare const isErrorEvent: <TData = any>(event: EventObject | ErrorEvent_2<TData>) => event is ErrorEvent_2<TData>;
+
+/**
+ * isErrorType.
+ * @param type - An event type.
+ * @public
+ */
+export declare const isErrorType: <TType extends ErrorConstructor>(type: TType) => (event: any) => boolean;
+
+/**
+ * @param error - An error.
+ * @public
+ */
+export declare const isGenesisServerError: (error: unknown) => boolean;
+
+/**
+ * @param error - An error.
+ * @public
+ */
+export declare const isMappingError: (error: unknown) => boolean;
+
+/**
+ * @param error - An error.
+ * @public
+ */
+export declare const isNetworkError: (error: unknown) => boolean;
+
+/**
+ * @param error - An error.
+ * @public
+ */
+export declare const isNotFoundError: (error: {
+    status?: number;
+}) => boolean;
+
+/**
+ * isSyntaxError.
+ * @public
+ */
+export declare const isSyntaxError: ({ event }: {
+    event: any;
+}) => boolean;
+
+/**
+ * isTypeError.
+ * @public
+ */
+export declare const isTypeError: ({ event }: {
+    event: any;
+}) => boolean;
+
+/**
+ * @public
+ */
+export declare const logger: Logger;
+
+/**
+ * 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 declare 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;
+}
+
+/**
+ * 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 declare interface MachineContext extends MachineContext_2 {
+    /**
+     * 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;
+}
+
+/**
+ * MappingError.
+ * @public
+ */
+export declare class MappingError extends Error {
+    dto?: unknown;
+    constructor(dto?: unknown, message?: string);
+}
+
+/**
+ * NetworkError.
+ * @remarks
+ * Failed to reach server.
+ * @public
+ */
+export declare class NetworkError extends Error {
+    url: string;
+    constructor(url: string, message?: string);
+}
+
+/**
+ * ResponseDataExtractor type.
+ * @remarks
+ * Extracts data from the {@link typescript#Response} and processes it accordingly. The default data extractor will inspect
+ * `content-type` and call `JSON.parse()` if it includes `application/json`. Custom data extractors can be used here.
+ * @privateRemarks
+ * Need to find out if the Genesis http layer returns mixed responses. If needed we can catch and return just the text.
+ * @typeParam TData - The expected data type. Defaults to any;
+ * @param response - The {@link typescript#Response}.
+ * @returns The extracted data.
+ * @public
+ */
+export declare type ResponseDataExtractor<TData = any> = (response: Response) => Promise<TData>;
+
+/**
+ * ResponseOkChecker type.
+ * @privateRemarks
+ * Genesis HTTP-Based APIs may provide unexpected status codes, so special handling can be required.
+ * @param response - The {@link typescript#Response}.
+ * @returns A boolean to indicate if the response is ok.
+ * @public
+ */
+export declare type ResponseOkChecker = (response: Response) => boolean;
+
+/**
+ * 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: {
+    (_: ActionArgs<MachineContext_2, EventObject, ParameterizedObject>): void;
+    type: string;
+    assignment: Assigner<MachineContext_2, EventObject> | PropertyAssigner<MachineContext_2, EventObject>;
+    resolve: (actorContext: AnyActorContext, state: AnyState, actionArgs: ActionArgs<any, any, ParameterizedObject>, { assignment }: {
+        assignment: Assigner<any, any> | PropertyAssigner<any, any>;
+    }) => 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) => {
+    (_: ActionArgs<MachineContext_2, EventObject, ParameterizedObject>): void;
+    type: string;
+    assignment: Assigner<MachineContext_2, EventObject> | PropertyAssigner<MachineContext_2, EventObject>;
+    resolve: (actorContext: AnyActorContext, state: AnyState, actionArgs: ActionArgs<any, any, ParameterizedObject>, { assignment }: {
+        assignment: Assigner<any, any> | PropertyAssigner<any, any>;
+    }) => AnyState[];
+};
+
+/**
+ * @typeParam TReturn - The return type.
+ * @param value - The bound value.
+ * @param args - A binding observer.
+ * @internal
+ */
+export declare 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 declare type SubscriberChangeHandler<TTarget = any, TReturn = any> = (binding: (x?: TTarget, context?: ExecutionContext) => TReturn, args: BindingObserver) => void;
+
+/**
+ * @typeParam TTarget - The target interface.
+ * @param target - The target.
+ * @internal
+ */
+export declare type TargetBinding<TTarget = any> = (target: TTarget) => any;
+
+/**
+ * @typeParam TTarget - The target interface.
+ * @typeParam TReturn - The return type.
+ * @internal
+ */
+export declare interface TargetSubscriber<TTarget = any, TReturn = any> {
+    handleChange: SubscriberChangeHandler<TTarget, TReturn>;
+}
+
+export { }