import * as i0 from '@angular/core';
import { ErrorHandler } from '@angular/core';
import { Observable, OperatorFunction } from 'rxjs';

type ValuesOf<O> = O[keyof O];
type InstanceOrType<T> = T extends abstract new (...args: any) => infer R ? R : T;
type InferArguments<T> = T extends (...args: infer R) => any ? R : never;
type Select<U, K> = K extends keyof U ? U[K] : never;
type ExtractString<T extends object> = Extract<keyof T, string>;
type FunctionParamsOrValueType<U, K, F> = InferArguments<Select<U, K>> extends never ? [F] : InferArguments<Select<U, K>>;
type Actions = object;
type ActionTransforms<T extends object> = Partial<{
    [K in keyof T]: (...args: any[]) => T[K];
}>;
type ActionDispatchFn<O extends unknown[]> = (...value: InstanceOrType<O>) => void;
type ActionDispatchers<T extends Actions, U extends object> = {
    [K in keyof T]: ActionDispatchFn<FunctionParamsOrValueType<U, K, Select<T, K>>>;
};
type ActionObservables<T extends Actions> = {
    [K in ExtractString<T> as `${K}$`]: Observable<InstanceOrType<T[K]>>;
};
type ActionEffects<T extends Actions, O = T> = {
    [K in ExtractString<T> as `on${Capitalize<string & K>}`]: <R>(fn: OperatorFunction<T[K], R>, sideEffectFn?: (value: R) => void) => () => void;
};
type RxActions<T extends Actions, U extends object = T> = ActionDispatchers<T, U> & ActionObservables<T> & ActionEffects<T> & ((slice: Partial<T>) => void) & {
    $: (props: (keyof T)[]) => Observable<ValuesOf<T>>;
};

/**
 * @deprecated - use rxActions instead
 *
 * This class creates RxActions bound to Angular's DI life-cycles. This prevents memory leaks and optionally makes the instance reusable across the app.
 * The function has to be used inside an injection context.
 * If the consumer gets destroyed also the actions get destroyed automatically.
 *
 * @example
 * @Component({
 *   standalone: true,
 *   template: `...`,
 * })
 * export class AnyComponent {
 *   ui = rxActions<{search: string, refresh: void}>();
 * }
 */
declare class RxActionFactory<T extends Partial<Actions>> {
    private readonly errorHandler?;
    private readonly subjects;
    constructor(errorHandler?: ErrorHandler | undefined);
    create<U extends ActionTransforms<T> = object>(transforms?: U): RxActions<T, U>;
    destroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RxActionFactory<any>, [{ optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RxActionFactory<any>>;
}

/**
 * Manage events in components and services in a single place
 *
 * @example
 *
 * interface UI {
 *  search: string,
 *  submit: void
 * };
 *
 * import { rxActions } from '@rx-angular/state/actions';
 *
 * @Component({...})
 * export class Component {
 *   ui = rxActions<{ name: string }>(({transforms}) => transforms({name: v => v}));
 *
 *   name$ = this.ui.name$; // Observable<string> - listens to name changes
 *   emitName = this.ui.name; // (name: string) => void - emits name change
 *   sub = this.ui.onName(o$ => o$.pipe(), console.log) // () => void - stops side effect
 *
 *   onInit() {
 *     const name$ = this.ui.name$; // Observable<string> - listens to name changes
 *     const emitName = this.ui.name; // (name: string) => void - emits name change
 *     const stop = this.ui.onName(o$ => o$.pipe(), console.log) // () => void - stops side effect
 *     stop();
 *   }
 *
 * }
 *
 */
declare function rxActions<T extends Partial<Actions>, U extends ActionTransforms<T> = object>(setupFn?: (cfg: {
    transforms: (t: U) => void;
}) => void): RxActions<T, U>;

/**
 * @description
 * This transform is a side effecting operation applying `preventDefault` to a passed Event
 * @param e
 */
declare function preventDefault(e: Event): Event;
/**
 * @description
 * This transform is a side effecting operation applying `stopPropagation` to a passed Event
 * @param e
 */
declare function stopPropagation(e: Event): Event;
/**
 * @description
 * This transform is a side effecting operation applying `preventDefault` and `stopPropagation` to a passed Event
 * @param e
 */
declare function preventDefaultStopPropagation(e: Event): Event;
/**
 * @description
 * This transform is helps to pluck values from DOM `Event` or forward the value directly.
 * @param e
 */
declare function eventValue<T = string>(e: Event | T): T;

export { RxActionFactory, eventValue, preventDefault, preventDefaultStopPropagation, rxActions, stopPropagation };
export type { ActionDispatchFn, ActionDispatchers, ActionObservables, ActionTransforms, RxActions };
//# sourceMappingURL=rx-angular-state-actions.d.ts.map