xstate 5.32.1 → 6.0.0-alpha.1

package/dist/assign-927227d6.development.cjs.js

@@ -1,135 +0,0 @@
-'use strict';
-
-var dist_xstateGuards = require('./raise-964cd4e9.development.cjs.js');
-
-function createSpawner(actorScope, {
-  machine,
-  context
-}, event, spawnedChildren) {
-  const spawn = (src, options) => {
-    if (typeof src === 'string') {
-      const logic = dist_xstateGuards.resolveReferencedActor(machine, src);
-      if (!logic) {
-        throw new Error(`Actor logic '${src}' not implemented in machine '${machine.id}'`);
-      }
-      const actorRef = dist_xstateGuards.createActor(logic, {
-        id: options?.id,
-        parent: actorScope.self,
-        syncSnapshot: options?.syncSnapshot,
-        input: typeof options?.input === 'function' ? options.input({
-          context,
-          event,
-          self: actorScope.self
-        }) : options?.input,
-        src,
-        systemId: options?.systemId
-      });
-      spawnedChildren[actorRef.id] = actorRef;
-      return actorRef;
-    } else {
-      const actorRef = dist_xstateGuards.createActor(src, {
-        id: options?.id,
-        parent: actorScope.self,
-        syncSnapshot: options?.syncSnapshot,
-        input: options?.input,
-        src,
-        systemId: options?.systemId
-      });
-      return actorRef;
-    }
-  };
-  return (src, options) => {
-    const actorRef = spawn(src, options); // TODO: fix types
-    spawnedChildren[actorRef.id] = actorRef;
-    actorScope.defer(() => {
-      if (actorRef._processingStatus === dist_xstateGuards.ProcessingStatus.Stopped) {
-        return;
-      }
-      actorRef.start();
-    });
-    return actorRef;
-  };
-}
-
-function resolveAssign(actorScope, snapshot, actionArgs, actionParams, {
-  assignment
-}) {
-  if (!snapshot.context) {
-    throw new Error('Cannot assign to undefined `context`. Ensure that `context` is defined in the machine config.');
-  }
-  const spawnedChildren = {};
-  const assignArgs = {
-    context: snapshot.context,
-    event: actionArgs.event,
-    spawn: createSpawner(actorScope, snapshot, actionArgs.event, spawnedChildren),
-    self: actorScope.self,
-    system: actorScope.system
-  };
-  let partialUpdate = {};
-  if (typeof assignment === 'function') {
-    partialUpdate = assignment(assignArgs, actionParams);
-  } else {
-    for (const key of Object.keys(assignment)) {
-      const propAssignment = assignment[key];
-      partialUpdate[key] = typeof propAssignment === 'function' ? propAssignment(assignArgs, actionParams) : propAssignment;
-    }
-  }
-  const updatedContext = Object.assign({}, snapshot.context, partialUpdate);
-  return [dist_xstateGuards.cloneMachineSnapshot(snapshot, {
-    context: updatedContext,
-    children: Object.keys(spawnedChildren).length ? {
-      ...snapshot.children,
-      ...spawnedChildren
-    } : snapshot.children
-  }), undefined, undefined];
-}
-/**
- * Updates the current context of the machine.
- *
- * @example
- *
- * ```ts
- * import { createMachine, assign } from 'xstate';
- *
- * const countMachine = createMachine({
- *   context: {
- *     count: 0,
- *     message: ''
- *   },
- *   on: {
- *     inc: {
- *       actions: assign({
- *         count: ({ context }) => context.count + 1
- *       })
- *     },
- *     updateMessage: {
- *       actions: assign(({ context, event }) => {
- *         return {
- *           message: event.message.trim()
- *         };
- *       })
- *     }
- *   }
- * });
- * ```
- *
- * @param assignment An object that represents the partial context to update, or
- *   a function that returns an object that represents the partial context to
- *   update.
- */
-function assign(assignment) {
-  if (dist_xstateGuards.executingCustomAction) {
-    console.warn('Custom actions should not call `assign()` directly, as it is not imperative. See https://stately.ai/docs/actions#built-in-actions for more details.');
-  }
-  function assign(_args, _params) {
-    {
-      throw new Error(`This isn't supposed to be called`);
-    }
-  }
-  assign.type = 'xstate.assign';
-  assign.assignment = assignment;
-  assign.resolve = resolveAssign;
-  return assign;
-}
-
-exports.assign = assign;

package/dist/assign-e8f2bd75.cjs.js

@@ -1,129 +0,0 @@
-'use strict';
-
-var dist_xstateGuards = require('./raise-7c948725.cjs.js');
-
-function createSpawner(actorScope, {
-  machine,
-  context
-}, event, spawnedChildren) {
-  const spawn = (src, options) => {
-    if (typeof src === 'string') {
-      const logic = dist_xstateGuards.resolveReferencedActor(machine, src);
-      if (!logic) {
-        throw new Error(`Actor logic '${src}' not implemented in machine '${machine.id}'`);
-      }
-      const actorRef = dist_xstateGuards.createActor(logic, {
-        id: options?.id,
-        parent: actorScope.self,
-        syncSnapshot: options?.syncSnapshot,
-        input: typeof options?.input === 'function' ? options.input({
-          context,
-          event,
-          self: actorScope.self
-        }) : options?.input,
-        src,
-        systemId: options?.systemId
-      });
-      spawnedChildren[actorRef.id] = actorRef;
-      return actorRef;
-    } else {
-      const actorRef = dist_xstateGuards.createActor(src, {
-        id: options?.id,
-        parent: actorScope.self,
-        syncSnapshot: options?.syncSnapshot,
-        input: options?.input,
-        src,
-        systemId: options?.systemId
-      });
-      return actorRef;
-    }
-  };
-  return (src, options) => {
-    const actorRef = spawn(src, options); // TODO: fix types
-    spawnedChildren[actorRef.id] = actorRef;
-    actorScope.defer(() => {
-      if (actorRef._processingStatus === dist_xstateGuards.ProcessingStatus.Stopped) {
-        return;
-      }
-      actorRef.start();
-    });
-    return actorRef;
-  };
-}
-
-function resolveAssign(actorScope, snapshot, actionArgs, actionParams, {
-  assignment
-}) {
-  if (!snapshot.context) {
-    throw new Error('Cannot assign to undefined `context`. Ensure that `context` is defined in the machine config.');
-  }
-  const spawnedChildren = {};
-  const assignArgs = {
-    context: snapshot.context,
-    event: actionArgs.event,
-    spawn: createSpawner(actorScope, snapshot, actionArgs.event, spawnedChildren),
-    self: actorScope.self,
-    system: actorScope.system
-  };
-  let partialUpdate = {};
-  if (typeof assignment === 'function') {
-    partialUpdate = assignment(assignArgs, actionParams);
-  } else {
-    for (const key of Object.keys(assignment)) {
-      const propAssignment = assignment[key];
-      partialUpdate[key] = typeof propAssignment === 'function' ? propAssignment(assignArgs, actionParams) : propAssignment;
-    }
-  }
-  const updatedContext = Object.assign({}, snapshot.context, partialUpdate);
-  return [dist_xstateGuards.cloneMachineSnapshot(snapshot, {
-    context: updatedContext,
-    children: Object.keys(spawnedChildren).length ? {
-      ...snapshot.children,
-      ...spawnedChildren
-    } : snapshot.children
-  }), undefined, undefined];
-}
-/**
- * Updates the current context of the machine.
- *
- * @example
- *
- * ```ts
- * import { createMachine, assign } from 'xstate';
- *
- * const countMachine = createMachine({
- *   context: {
- *     count: 0,
- *     message: ''
- *   },
- *   on: {
- *     inc: {
- *       actions: assign({
- *         count: ({ context }) => context.count + 1
- *       })
- *     },
- *     updateMessage: {
- *       actions: assign(({ context, event }) => {
- *         return {
- *           message: event.message.trim()
- *         };
- *       })
- *     }
- *   }
- * });
- * ```
- *
- * @param assignment An object that represents the partial context to update, or
- *   a function that returns an object that represents the partial context to
- *   update.
- */
-function assign(assignment) {
-  function assign(_args, _params) {
-  }
-  assign.type = 'xstate.assign';
-  assign.assignment = assignment;
-  assign.resolve = resolveAssign;
-  return assign;
-}
-
-exports.assign = assign;

package/dist/assign-f338cee3.development.esm.js

@@ -1,133 +0,0 @@
-import { _ as ProcessingStatus, V as resolveReferencedActor, c as createActor, a0 as cloneMachineSnapshot, W as executingCustomAction } from './raise-74097812.development.esm.js';
-
-function createSpawner(actorScope, {
-  machine,
-  context
-}, event, spawnedChildren) {
-  const spawn = (src, options) => {
-    if (typeof src === 'string') {
-      const logic = resolveReferencedActor(machine, src);
-      if (!logic) {
-        throw new Error(`Actor logic '${src}' not implemented in machine '${machine.id}'`);
-      }
-      const actorRef = createActor(logic, {
-        id: options?.id,
-        parent: actorScope.self,
-        syncSnapshot: options?.syncSnapshot,
-        input: typeof options?.input === 'function' ? options.input({
-          context,
-          event,
-          self: actorScope.self
-        }) : options?.input,
-        src,
-        systemId: options?.systemId
-      });
-      spawnedChildren[actorRef.id] = actorRef;
-      return actorRef;
-    } else {
-      const actorRef = createActor(src, {
-        id: options?.id,
-        parent: actorScope.self,
-        syncSnapshot: options?.syncSnapshot,
-        input: options?.input,
-        src,
-        systemId: options?.systemId
-      });
-      return actorRef;
-    }
-  };
-  return (src, options) => {
-    const actorRef = spawn(src, options); // TODO: fix types
-    spawnedChildren[actorRef.id] = actorRef;
-    actorScope.defer(() => {
-      if (actorRef._processingStatus === ProcessingStatus.Stopped) {
-        return;
-      }
-      actorRef.start();
-    });
-    return actorRef;
-  };
-}
-
-function resolveAssign(actorScope, snapshot, actionArgs, actionParams, {
-  assignment
-}) {
-  if (!snapshot.context) {
-    throw new Error('Cannot assign to undefined `context`. Ensure that `context` is defined in the machine config.');
-  }
-  const spawnedChildren = {};
-  const assignArgs = {
-    context: snapshot.context,
-    event: actionArgs.event,
-    spawn: createSpawner(actorScope, snapshot, actionArgs.event, spawnedChildren),
-    self: actorScope.self,
-    system: actorScope.system
-  };
-  let partialUpdate = {};
-  if (typeof assignment === 'function') {
-    partialUpdate = assignment(assignArgs, actionParams);
-  } else {
-    for (const key of Object.keys(assignment)) {
-      const propAssignment = assignment[key];
-      partialUpdate[key] = typeof propAssignment === 'function' ? propAssignment(assignArgs, actionParams) : propAssignment;
-    }
-  }
-  const updatedContext = Object.assign({}, snapshot.context, partialUpdate);
-  return [cloneMachineSnapshot(snapshot, {
-    context: updatedContext,
-    children: Object.keys(spawnedChildren).length ? {
-      ...snapshot.children,
-      ...spawnedChildren
-    } : snapshot.children
-  }), undefined, undefined];
-}
-/**
- * Updates the current context of the machine.
- *
- * @example
- *
- * ```ts
- * import { createMachine, assign } from 'xstate';
- *
- * const countMachine = createMachine({
- *   context: {
- *     count: 0,
- *     message: ''
- *   },
- *   on: {
- *     inc: {
- *       actions: assign({
- *         count: ({ context }) => context.count + 1
- *       })
- *     },
- *     updateMessage: {
- *       actions: assign(({ context, event }) => {
- *         return {
- *           message: event.message.trim()
- *         };
- *       })
- *     }
- *   }
- * });
- * ```
- *
- * @param assignment An object that represents the partial context to update, or
- *   a function that returns an object that represents the partial context to
- *   update.
- */
-function assign(assignment) {
-  if (executingCustomAction) {
-    console.warn('Custom actions should not call `assign()` directly, as it is not imperative. See https://stately.ai/docs/actions#built-in-actions for more details.');
-  }
-  function assign(_args, _params) {
-    {
-      throw new Error(`This isn't supposed to be called`);
-    }
-  }
-  assign.type = 'xstate.assign';
-  assign.assignment = assignment;
-  assign.resolve = resolveAssign;
-  return assign;
-}
-
-export { assign as a };

package/dist/declarations/src/actions/assign.d.ts

@@ -1,45 +0,0 @@
-import { Spawner } from "../spawn.js";
-import type { ActionArgs, AnyEventObject, Assigner, EventObject, LowInfer, MachineContext, ParameterizedObject, PropertyAssigner, ProvidedActor, ActionFunction } from "../types.js";
-export interface AssignArgs<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TActor extends ProvidedActor> extends ActionArgs<TContext, TExpressionEvent, TEvent> {
-    spawn: Spawner<TActor>;
-}
-export interface AssignAction<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TActor extends ProvidedActor> {
-    (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams): void;
-    _out_TActor?: TActor;
-}
-/**
- * Updates the current context of the machine.
- *
- * @example
- *
- * ```ts
- * import { createMachine, assign } from 'xstate';
- *
- * const countMachine = createMachine({
- *   context: {
- *     count: 0,
- *     message: ''
- *   },
- *   on: {
- *     inc: {
- *       actions: assign({
- *         count: ({ context }) => context.count + 1
- *       })
- *     },
- *     updateMessage: {
- *       actions: assign(({ context, event }) => {
- *         return {
- *           message: event.message.trim()
- *         };
- *       })
- *     }
- *   }
- * });
- * ```
- *
- * @param assignment An object that represents the partial context to update, or
- *   a function that returns an object that represents the partial context to
- *   update.
- */
-export declare function assign<TContext extends MachineContext, TExpressionEvent extends AnyEventObject, // TODO: consider using a stricter `EventObject` here
-TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TActor extends ProvidedActor>(assignment: Assigner<LowInfer<TContext>, TExpressionEvent, TParams, TEvent, TActor> | PropertyAssigner<LowInfer<TContext>, TExpressionEvent, TParams, TEvent, TActor>): ActionFunction<TContext, TExpressionEvent, TEvent, TParams, TActor, never, never, never, never>;

package/dist/declarations/src/actions/cancel.d.ts

@@ -1,39 +0,0 @@
-import { EventObject, MachineContext, ActionArgs, ParameterizedObject } from "../types.js";
-type ResolvableSendId<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject> = string | ((args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams) => string);
-export interface CancelAction<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject> {
-    (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams): void;
-}
-/**
- * Cancels a delayed `sendTo(...)` action that is waiting to be executed. The
- * canceled `sendTo(...)` action will not send its event or execute, unless the
- * `delay` has already elapsed before `cancel(...)` is called.
- *
- * @example
- *
- * ```ts
- * import { createMachine, sendTo, cancel } from 'xstate';
- *
- * const machine = createMachine({
- *   // ...
- *   on: {
- *     sendEvent: {
- *       actions: sendTo(
- *         'some-actor',
- *         { type: 'someEvent' },
- *         {
- *           id: 'some-id',
- *           delay: 1000
- *         }
- *       )
- *     },
- *     cancelEvent: {
- *       actions: cancel('some-id')
- *     }
- *   }
- * });
- * ```
- *
- * @param sendId The `id` of the `sendTo(...)` action to cancel.
- */
-export declare function cancel<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject>(sendId: ResolvableSendId<TContext, TExpressionEvent, TParams, TEvent>): CancelAction<TContext, TExpressionEvent, TParams, TEvent>;
-export {};

package/dist/declarations/src/actions/emit.d.ts

@@ -1,44 +0,0 @@
-import { ActionArgs, ActionFunction, AnyEventObject, DoNotInfer, EventObject, MachineContext, ParameterizedObject, SendExpr } from "../types.js";
-export interface EmitAction<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TEmitted extends EventObject> {
-    (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams): void;
-    _out_TEmitted?: TEmitted;
-}
-/**
- * Emits an event to event handlers registered on the actor via `actor.on(event,
- * handler)`.
- *
- * @example
- *
- * ```ts
- * import { emit } from 'xstate';
- *
- * const machine = createMachine({
- *   // ...
- *   on: {
- *     something: {
- *       actions: emit({
- *         type: 'emitted',
- *         some: 'data'
- *       })
- *     }
- *   }
- *   // ...
- * });
- *
- * const actor = createActor(machine).start();
- *
- * actor.on('emitted', (event) => {
- *   console.log(event);
- * });
- *
- * actor.send({ type: 'something' });
- * // logs:
- * // {
- * //   type: 'emitted',
- * //   some: 'data'
- * // }
- * ```
- */
-export declare function emit<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TEmitted extends AnyEventObject>(
-/** The event to emit, or an expression that returns an event to emit. */
-eventOrExpr: DoNotInfer<TEmitted> | SendExpr<TContext, TExpressionEvent, TParams, DoNotInfer<TEmitted>, TEvent>): ActionFunction<TContext, TExpressionEvent, TEvent, TParams, never, never, never, never, TEmitted>;

package/dist/declarations/src/actions/enqueueActions.d.ts

@@ -1,57 +0,0 @@
-import { Guard } from "../guards.js";
-import { Action, ActionArgs, ActionFunction, AnyActorRef, AnyEventObject, EventObject, MachineContext, ParameterizedObject, ProvidedActor, UnifiedArg } from "../types.js";
-import { assign } from "./assign.js";
-import { cancel } from "./cancel.js";
-import { emit } from "./emit.js";
-import { raise } from "./raise.js";
-import { sendParent, sendTo } from "./send.js";
-import { spawnChild } from "./spawnChild.js";
-import { stopChild } from "./stopChild.js";
-interface ActionEnqueuer<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TEmitted extends EventObject> {
-    (action: Action<TContext, TExpressionEvent, TEvent, undefined, TActor, TAction, TGuard, TDelay, TEmitted>): void;
-    assign: (...args: Parameters<typeof assign<TContext, TExpressionEvent, undefined, TEvent, TActor>>) => void;
-    cancel: (...args: Parameters<typeof cancel<TContext, TExpressionEvent, undefined, TEvent>>) => void;
-    raise: (...args: Parameters<typeof raise<TContext, TExpressionEvent, TEvent, undefined, TDelay, TDelay>>) => void;
-    sendTo: <TTargetActor extends AnyActorRef>(...args: Parameters<typeof sendTo<TContext, TExpressionEvent, undefined, TTargetActor, TEvent, TDelay, TDelay>>) => void;
-    sendParent: (...args: Parameters<typeof sendParent<TContext, TExpressionEvent, undefined, AnyEventObject, TEvent, TDelay, TDelay>>) => void;
-    spawnChild: (...args: Parameters<typeof spawnChild<TContext, TExpressionEvent, undefined, TEvent, TActor>>) => void;
-    stopChild: (...args: Parameters<typeof stopChild<TContext, TExpressionEvent, undefined, TEvent>>) => void;
-    emit: (...args: Parameters<typeof emit<TContext, TExpressionEvent, undefined, TEvent, TEmitted>>) => void;
-}
-export interface EnqueueActionsAction<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string> {
-    (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams): void;
-    _out_TEvent?: TEvent;
-    _out_TActor?: TActor;
-    _out_TAction?: TAction;
-    _out_TGuard?: TGuard;
-    _out_TDelay?: TDelay;
-}
-interface CollectActionsArg<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TEmitted extends EventObject> extends UnifiedArg<TContext, TExpressionEvent, TEvent> {
-    check: (guard: Guard<TContext, TExpressionEvent, undefined, TGuard>) => boolean;
-    enqueue: ActionEnqueuer<TContext, TExpressionEvent, TEvent, TActor, TAction, TGuard, TDelay, TEmitted>;
-}
-type CollectActions<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TEmitted extends EventObject> = ({ context, event, check, enqueue, self }: CollectActionsArg<TContext, TExpressionEvent, TEvent, TActor, TAction, TGuard, TDelay, TEmitted>, params: TParams) => void;
-/**
- * Creates an action object that will execute actions that are queued by the
- * `enqueue(action)` function.
- *
- * @example
- *
- * ```ts
- * import { createMachine, enqueueActions } from 'xstate';
- *
- * const machine = createMachine({
- *   entry: enqueueActions(({ enqueue, check }) => {
- *     enqueue.assign({ count: 0 });
- *
- *     if (check('someGuard')) {
- *       enqueue.assign({ count: 1 });
- *     }
- *
- *     enqueue('someAction');
- *   })
- * });
- * ```
- */
-export declare function enqueueActions<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject = TExpressionEvent, TActor extends ProvidedActor = ProvidedActor, TAction extends ParameterizedObject = ParameterizedObject, TGuard extends ParameterizedObject = ParameterizedObject, TDelay extends string = never, TEmitted extends EventObject = EventObject>(collect: CollectActions<TContext, TExpressionEvent, TParams, TEvent, TActor, TAction, TGuard, TDelay, TEmitted>): ActionFunction<TContext, TExpressionEvent, TEvent, TParams, TActor, TAction, TGuard, TDelay, TEmitted>;
-export {};

package/dist/declarations/src/actions/log.d.ts

@@ -1,16 +0,0 @@
-import { ActionArgs, EventObject, LogExpr, MachineContext, ParameterizedObject } from "../types.js";
-type ResolvableLogValue<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject> = string | LogExpr<TContext, TExpressionEvent, TParams, TEvent>;
-export interface LogAction<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject> {
-    (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams): void;
-}
-/**
- * @param expr The expression function to evaluate which will be logged. Takes
- *   in 2 arguments:
- *
- *   - `ctx` - the current state context
- *   - `event` - the event that caused this action to be executed.
- *
- * @param label The label to give to the logged expression.
- */
-export declare function log<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject>(value?: ResolvableLogValue<TContext, TExpressionEvent, TParams, TEvent>, label?: string): LogAction<TContext, TExpressionEvent, TParams, TEvent>;
-export {};

package/dist/declarations/src/actions/raise.d.ts

@@ -1,21 +0,0 @@
-import { ActionArgs, ActionFunction, DoNotInfer, EventObject, ExecutableActionObject, MachineContext, ParameterizedObject, RaiseActionOptions, SendExpr } from "../types.js";
-export interface RaiseAction<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TDelay extends string> {
-    (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams): void;
-    _out_TEvent?: TEvent;
-    _out_TDelay?: TDelay;
-}
-/**
- * Raises an event. This places the event in the internal event queue, so that
- * the event is immediately consumed by the machine in the current step.
- *
- * @param eventType The event to raise.
- */
-export declare function raise<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TDelay extends string = never, TUsedDelay extends TDelay = never>(eventOrExpr: DoNotInfer<TEvent> | SendExpr<TContext, TExpressionEvent, TParams, DoNotInfer<TEvent>, TEvent>, options?: RaiseActionOptions<TContext, TExpressionEvent, TParams, DoNotInfer<TEvent>, TUsedDelay>): ActionFunction<TContext, TExpressionEvent, TEvent, TParams, never, never, never, TDelay, never>;
-export interface ExecutableRaiseAction extends ExecutableActionObject {
-    type: 'xstate.raise';
-    params: {
-        event: EventObject;
-        id: string | undefined;
-        delay: number | undefined;
-    };
-}

package/dist/declarations/src/actions/send.d.ts

@@ -1,42 +0,0 @@
-import { ActionArgs, ActionFunction, AnyActorRef, AnyEventObject, Cast, DoNotInfer, EventFrom, EventObject, ExecutableActionObject, InferEvent, MachineContext, ParameterizedObject, SendExpr, SendToActionOptions } from "../types.js";
-export interface SendToAction<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TDelay extends string> {
-    (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams): void;
-    _out_TDelay?: TDelay;
-}
-/**
- * Sends an event to an actor.
- *
- * @param actor The `ActorRef` to send the event to.
- * @param event The event to send, or an expression that evaluates to the event
- *   to send
- * @param options Send action options
- *
- *   - `id` - The unique send event identifier (used with `cancel()`).
- *   - `delay` - The number of milliseconds to delay the sending of the event.
- */
-export declare function sendTo<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TTargetActor extends AnyActorRef, TEvent extends EventObject, TDelay extends string = never, TUsedDelay extends TDelay = never>(to: SendToActionTarget<TContext, TExpressionEvent, TParams, TTargetActor, TEvent>, eventOrExpr: EventFrom<TTargetActor> | SendExpr<TContext, TExpressionEvent, TParams, InferEvent<Cast<EventFrom<TTargetActor>, EventObject>>, TEvent>, options?: SendToActionOptions<TContext, TExpressionEvent, TParams, DoNotInfer<TEvent>, TUsedDelay>): ActionFunction<TContext, TExpressionEvent, TEvent, TParams, never, never, never, TDelay, never>;
-/**
- * Sends an event to this machine's parent.
- *
- * @param event The event to send to the parent machine.
- * @param options Options to pass into the send event.
- */
-export declare function sendParent<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TSentEvent extends EventObject = AnyEventObject, TEvent extends EventObject = AnyEventObject, TDelay extends string = never, TUsedDelay extends TDelay = never>(event: TSentEvent | SendExpr<TContext, TExpressionEvent, TParams, TSentEvent, TEvent>, options?: SendToActionOptions<TContext, TExpressionEvent, TParams, TEvent, TUsedDelay>): ActionFunction<TContext, TExpressionEvent, TEvent, TParams, never, never, never, TDelay, never>;
-type SendToActionTarget<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TTargetActor extends AnyActorRef, TEvent extends EventObject> = string | TTargetActor | ((args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams) => string | TTargetActor);
-/**
- * Forwards (sends) an event to the `target` actor.
- *
- * @param target The target actor to forward the event to.
- * @param options Options to pass into the send action creator.
- */
-export declare function forwardTo<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TDelay extends string = never, TUsedDelay extends TDelay = never>(target: SendToActionTarget<TContext, TExpressionEvent, TParams, AnyActorRef, TEvent>, options?: SendToActionOptions<TContext, TExpressionEvent, TParams, TEvent, TUsedDelay>): ActionFunction<TContext, TExpressionEvent, TEvent, TParams, never, never, never, TDelay, never>;
-export interface ExecutableSendToAction extends ExecutableActionObject {
-    type: 'xstate.sendTo';
-    params: {
-        event: EventObject;
-        id: string | undefined;
-        delay: number | undefined;
-        to: AnyActorRef;
-    };
-}
-export {};