@xstate/react

createActorContext: <TLogic extends AnyActorLogic>(
    actorLogic: TLogic,
    interpreterOptions?: ActorOptions<TLogic>
) => {
    useSelector: <T>(
        selector: (snapshot: SnapshotFrom<TLogic>) => T,
        compare?: (a: T, b: T) => boolean
    ) => T;
    useActorRef: () => ActorRefFrom<TLogic>;
    Provider: (
        props: {
            children: React.ReactNode;
            options?: ActorOptions<TLogic>;
            machine?: never;
        } & (TLogic extends AnyStateMachine
            ? AreAllImplementationsAssumedToBeProvided<
                  TLogic['__TResolvedTypesMeta']
              > extends true
                ? { logic?: TLogic }
                : { logic: ToMachinesWithProvidedImplementations<TLogic> }
            : { logic?: TLogic })
    ) => React.ReactElement<any, any>;
};

shallowEqual: (objA: any, objB: any) => boolean;

useActor: <TLogic extends AnyActorLogic>(
    logic: TLogic,
    options?: ActorOptions<TLogic>
) => [SnapshotFrom<TLogic>, ActorRefFrom<TLogic>['send'], ActorRefFrom<TLogic>];

useActorRef: <TLogic extends AnyActorLogic>(
    machine: TLogic,
    options?: ActorOptions<TLogic>,
    observerOrListener?: any
) => ActorRefFrom<TLogic>;

useMachine: <TMachine extends AnyStateMachine>(
    machine: AreAllImplementationsAssumedToBeProvided<
        TMachine['__TResolvedTypesMeta']
    > extends true
        ? TMachine
        : MissingImplementationsError<TMachine['__TResolvedTypesMeta']>,
    options?: ActorOptions<TMachine>
) => [StateFrom<TMachine>, ActorRefFrom<TMachine>['send'], ActorRefFrom<TMachine>];

useSelector: <TActor extends ActorRef<any, any>, T>(
    actor: TActor,
    selector: (emitted: SnapshotFrom<TActor>) => T,
    compare?: (a: T, b: T) => boolean
) => T;