@angular-architects/ngrx-toolkit 19.2.3 → 20.0.1

package/lib/with-call-state.d.ts

@@ -1,58 +0,0 @@
-import { Signal } from '@angular/core';
-import { EmptyFeatureResult, SignalStoreFeature } from '@ngrx/signals';
-export type CallState = 'init' | 'loading' | 'loaded' | {
-    error: string;
-};
-export type CallStateSlice = {
-    callState: CallState;
-};
-export type NamedCallStateSlice<Collection extends string> = {
-    [K in keyof CallStateSlice as Collection extends '' ? `${Collection}${K}` : `${Collection}${Capitalize<K>}`]: CallStateSlice[K];
-};
-export type CallStateSignals = {
-    loading: Signal<boolean>;
-    loaded: Signal<boolean>;
-    error: Signal<string | null>;
-};
-export type NamedCallStateSignals<Prop extends string> = {
-    [K in keyof CallStateSignals as Prop extends '' ? `${Prop}${K}` : `${Prop}${Capitalize<K>}`]: CallStateSignals[K];
-};
-export type SetCallState<Prop extends string | undefined> = Prop extends string ? NamedCallStateSlice<Prop> : CallStateSlice;
-export declare function deriveCallStateKeys<Collection extends string>(collection?: Collection): {
-    callStateKey: string;
-    loadingKey: string;
-    loadedKey: string;
-    errorKey: string;
-};
-export declare function getCallStateKeys(config?: {
-    collection?: string;
-}): {
-    callStateKey: string;
-    loadingKey: string;
-    loadedKey: string;
-    errorKey: string;
-};
-export declare function getCollectionArray(config: {
-    collection?: string;
-} | {
-    collections?: string[];
-}): string[] | undefined;
-export declare function withCallState<Collection extends string>(config: {
-    collections: Collection[];
-}): SignalStoreFeature<EmptyFeatureResult, EmptyFeatureResult & {
-    state: NamedCallStateSlice<Collection>;
-    props: NamedCallStateSignals<Collection>;
-}>;
-export declare function withCallState<Collection extends string>(config: {
-    collection: Collection;
-}): SignalStoreFeature<EmptyFeatureResult, EmptyFeatureResult & {
-    state: NamedCallStateSlice<Collection>;
-    props: NamedCallStateSignals<Collection>;
-}>;
-export declare function withCallState(): SignalStoreFeature<EmptyFeatureResult, EmptyFeatureResult & {
-    state: CallStateSlice;
-    props: CallStateSignals;
-}>;
-export declare function setLoading<Prop extends string | undefined = undefined>(prop?: Prop): SetCallState<Prop>;
-export declare function setLoaded<Prop extends string | undefined = undefined>(prop?: Prop): SetCallState<Prop>;
-export declare function setError<Prop extends string | undefined = undefined>(error: unknown, prop?: Prop): SetCallState<Prop>;

package/lib/with-conditional.d.ts

@@ -1,50 +0,0 @@
-import { SignalStoreFeature, SignalStoreFeatureResult, StateSignals } from '@ngrx/signals';
-/**
- * `withConditional` activates a feature based on a given condition.
- *
- * **Use Cases**
- * - Conditionally activate features based on the **store state** or other criteria.
- * - Choose between **two different implementations** of a feature.
- *
- * **Type Constraints**
- * Both features must have **exactly the same state, props, and methods**.
- * Otherwise, a type error will occur.
- *
- *
- * **Usage**
- *
- * ```typescript
- * const withUser = signalStoreFeature(
- *   withState({ id: 1, name: 'Konrad' }),
- *   withHooks(store => ({
- *     onInit() {
- *       // user loading logic
- *     }
- *   }))
- * );
- *
- * function withFakeUser() {
- *   return signalStoreFeature(
- *     withState({ id: 0, name: 'anonymous' })
- *   );
- * }
- *
- * signalStore(
- *   withMethods(() => ({
- *     useRealUser: () => true
- *   })),
- *   withConditional((store) => store.useRealUser(), withUser, withFakeUser)
- * )
- * ```
- *
- * @param condition - A function that determines which feature to activate based on the store state.
- * @param featureIfTrue - The feature to activate if the condition evaluates to `true`.
- * @param featureIfFalse - The feature to activate if the condition evaluates to `false`.
- * @returns A `SignalStoreFeature` that applies the selected feature based on the condition.
- */
-export declare function withConditional<Input extends SignalStoreFeatureResult, Output extends SignalStoreFeatureResult>(condition: (store: StateSignals<Input['state']> & Input['props'] & Input['methods']) => boolean, featureIfTrue: SignalStoreFeature<NoInfer<Input>, Output>, featureIfFalse: SignalStoreFeature<NoInfer<Input>, NoInfer<Output>>): SignalStoreFeature<Input, Output>;
-export declare const emptyFeature: SignalStoreFeature<import("@ngrx/signals").EmptyFeatureResult, {
-    state: {};
-    props: {};
-    methods: {};
-}>;

package/lib/with-data-service.d.ts

@@ -1,109 +0,0 @@
-import { ProviderToken, Signal } from '@angular/core';
-import { EmptyFeatureResult, SignalStoreFeature } from '@ngrx/signals';
-import { EntityId, NamedEntityState } from '@ngrx/signals/entities';
-import { EntityState } from './shared/signal-store-models';
-import { CallState, NamedCallStateSlice } from './with-call-state';
-export type Filter = Record<string, unknown>;
-export type Entity = {
-    id: EntityId;
-};
-export interface DataService<E extends Entity, F extends Filter> {
-    load(filter: F): Promise<E[]>;
-    loadById(id: EntityId): Promise<E>;
-    create(entity: E): Promise<E>;
-    update(entity: E): Promise<E>;
-    updateAll(entity: E[]): Promise<E[]>;
-    delete(entity: E): Promise<void>;
-}
-export declare function capitalize(str: string): string;
-export declare function getDataServiceKeys(options: {
-    collection?: string;
-}): {
-    filterKey: string;
-    selectedIdsKey: string;
-    selectedEntitiesKey: string;
-    updateFilterKey: string;
-    updateSelectedKey: string;
-    loadKey: string;
-    entitiesKey: string;
-    entityMapKey: string;
-    idsKey: string;
-    currentKey: string;
-    loadByIdKey: string;
-    setCurrentKey: string;
-    createKey: string;
-    updateKey: string;
-    updateAllKey: string;
-    deleteKey: string;
-};
-export type NamedDataServiceState<E extends Entity, F extends Filter, Collection extends string> = {
-    [K in Collection as `${K}Filter`]: F;
-} & {
-    [K in Collection as `selected${Capitalize<K>}Ids`]: Record<EntityId, boolean>;
-} & {
-    [K in Collection as `current${Capitalize<K>}`]: E;
-};
-export type DataServiceState<E extends Entity, F extends Filter> = {
-    filter: F;
-    selectedIds: Record<EntityId, boolean>;
-    current: E;
-};
-export type DataServiceComputed<E extends Entity> = {
-    selectedEntities: Signal<E[]>;
-};
-export type NamedDataServiceComputed<E extends Entity, Collection extends string> = {
-    [K in Collection as `selected${Capitalize<K>}Entities`]: Signal<E[]>;
-};
-export type NamedDataServiceMethods<E extends Entity, F extends Filter, Collection extends string> = {
-    [K in Collection as `update${Capitalize<K>}Filter`]: (filter: F) => void;
-} & {
-    [K in Collection as `updateSelected${Capitalize<K>}Entities`]: (id: EntityId, selected: boolean) => void;
-} & {
-    [K in Collection as `load${Capitalize<K>}Entities`]: () => Promise<void>;
-} & {
-    [K in Collection as `setCurrent${Capitalize<K>}`]: (entity: E) => void;
-} & {
-    [K in Collection as `load${Capitalize<K>}ById`]: (id: EntityId) => Promise<void>;
-} & {
-    [K in Collection as `create${Capitalize<K>}`]: (entity: E) => Promise<void>;
-} & {
-    [K in Collection as `update${Capitalize<K>}`]: (entity: E) => Promise<void>;
-} & {
-    [K in Collection as `updateAll${Capitalize<K>}`]: (entity: E[]) => Promise<void>;
-} & {
-    [K in Collection as `delete${Capitalize<K>}`]: (entity: E) => Promise<void>;
-};
-export type DataServiceMethods<E extends Entity, F extends Filter> = {
-    updateFilter: (filter: F) => void;
-    updateSelected: (id: EntityId, selected: boolean) => void;
-    load: () => Promise<void>;
-    setCurrent(entity: E): void;
-    loadById(id: EntityId): Promise<void>;
-    create(entity: E): Promise<void>;
-    update(entity: E): Promise<void>;
-    updateAll(entities: E[]): Promise<void>;
-    delete(entity: E): Promise<void>;
-};
-export declare function withDataService<E extends Entity, F extends Filter, Collection extends string>(options: {
-    dataServiceType: ProviderToken<DataService<E, F>>;
-    filter: F;
-    collection: Collection;
-}): SignalStoreFeature<EmptyFeatureResult & {
-    state: NamedCallStateSlice<Collection> & NamedEntityState<E, Collection>;
-}, {
-    state: NamedDataServiceState<E, F, Collection>;
-    props: NamedDataServiceComputed<E, Collection>;
-    methods: NamedDataServiceMethods<E, F, Collection>;
-}>;
-export declare function withDataService<E extends Entity, F extends Filter>(options: {
-    dataServiceType: ProviderToken<DataService<E, F>>;
-    filter: F;
-}): SignalStoreFeature<EmptyFeatureResult & {
-    state: {
-        callState: CallState;
-    } & EntityState<E>;
-}, {
-    state: DataServiceState<E, F>;
-    props: DataServiceComputed<E>;
-    methods: DataServiceMethods<E, F>;
-}>;

package/lib/with-feature-factory.d.ts

@@ -1,28 +0,0 @@
-import { SignalStoreFeature, SignalStoreFeatureResult, StateSignals } from '@ngrx/signals';
-type StoreForFactory<Input extends SignalStoreFeatureResult> = StateSignals<Input['state']> & Input['props'] & Input['methods'];
-/**
- * @deprecated Use `import { withFeature } from '@ngrx/signals'` instead, starting with `ngrx/signals` 19.1: https://ngrx.io/guide/signals/signal-store/custom-store-features#connecting-a-custom-feature-with-the-store
- *
- * Allows to pass properties, methods, or signals from a SignalStore
- * to a feature.
- *
- * Typically, a `signalStoreFeature` can have input constraints on
- *
- * ```typescript
- * function withSum(a: Signal<number>, b: Signal<number>) {
- *   return signalStoreFeature(
- *     withComputed(() => ({
- *       sum: computed(() => a() + b())
- *     }))
- *   );
- * }
- *
- * signalStore(
- *   withState({ a: 1, b: 2 }),
- *   withFeatureFactory((store) => withSum(store.a, store.b))
- * );
- * ```
- * @param factoryFn
- */
-export declare function withFeatureFactory<Input extends SignalStoreFeatureResult, Output extends SignalStoreFeatureResult>(factoryFn: (store: StoreForFactory<Input>) => SignalStoreFeature<Input, Output>): SignalStoreFeature<Input, Output>;
-export {};

package/lib/with-pagination.d.ts

@@ -1,98 +0,0 @@
-/** With pagination comes in two flavors the first one is local pagination or in memory pagination. For example we have 2000 items which we want
- * to display in a table and the response payload is small enough to be stored in the memory. But we can not display all 2000 items at once
- * so we need to paginate the data. The second flavor is server side pagination where the response payload is too large to be stored in the memory
- * and we need to fetch the data from the server in chunks. In the second case we 'could' also cache the data in the memory but that could lead to
- * other problems like memory leaks and stale data. So we will not cache the data in the memory in the second case.
- * This feature implements the local pagination.
- */
-import { Signal } from '@angular/core';
-import { EmptyFeatureResult, SignalStoreFeature } from '@ngrx/signals';
-export type Page = {
-    label: string | number;
-    value: number;
-};
-export type NamedPaginationServiceState<E, Collection extends string> = {
-    [K in Collection as `selectedPage${Capitalize<K>}Entities`]: Array<E>;
-} & {
-    [K in Collection as `${Lowercase<K>}CurrentPage`]: number;
-} & {
-    [K in Collection as `${Lowercase<K>}PageSize`]: number;
-} & {
-    [K in Collection as `${Lowercase<K>}TotalCount`]: number;
-} & {
-    [K in Collection as `${Lowercase<K>}PageCount`]: number;
-} & {
-    [K in Collection as `${Lowercase<K>}PageNavigationArray`]: number;
-} & {
-    [K in Collection as `${Lowercase<K>}PageNavigationArrayMax`]: number;
-};
-export type NamedPaginationServiceSignals<E, Collection extends string> = {
-    [K in Collection as `selectedPage${Capitalize<K>}Entities`]: Signal<E[]>;
-} & {
-    [K in Collection as `${Lowercase<K>}CurrentPage`]: Signal<number>;
-} & {
-    [K in Collection as `${Lowercase<K>}PageSize`]: Signal<number>;
-} & {
-    [K in Collection as `${Lowercase<K>}TotalCount`]: Signal<number>;
-} & {
-    [K in Collection as `${Lowercase<K>}PageCount`]: Signal<number>;
-} & {
-    [K in Collection as `${Lowercase<K>}PageNavigationArray`]: Signal<Page[]>;
-} & {
-    [K in Collection as `${Lowercase<K>}PageNavigationArrayMax`]: Signal<number>;
-} & {
-    [K in Collection as `hasNext${Capitalize<K>}Page`]: Signal<boolean>;
-} & {
-    [K in Collection as `hasPrevious${Capitalize<K>}Page`]: Signal<boolean>;
-};
-export type PaginationServiceState<E> = {
-    selectedPageEntities: Array<E>;
-    currentPage: number;
-    pageSize: number;
-    totalCount: number;
-    pageCount: number;
-    pageNavigationArray: Page[];
-    pageNavigationArrayMax: number;
-};
-export type PaginationServiceSignals<E> = {
-    selectedPageEntities: Signal<E[]>;
-    currentPage: Signal<number>;
-    pageSize: Signal<number>;
-    totalCount: Signal<number>;
-    pageCount: Signal<number>;
-    pageNavigationArray: Signal<Page[]>;
-    pageNavigationArrayMax: Signal<number>;
-    hasNextPage: Signal<boolean>;
-    hasPreviousPage: Signal<boolean>;
-};
-export type SetPaginationState<E, Collection extends string | undefined> = Collection extends string ? NamedPaginationServiceState<E, Collection> : PaginationServiceState<E>;
-export declare function withPagination<E, Collection extends string>(options: {
-    entity: E;
-    collection: Collection;
-}): SignalStoreFeature<EmptyFeatureResult, EmptyFeatureResult & {
-    state: NamedPaginationServiceState<E, Collection>;
-    props: NamedPaginationServiceSignals<E, Collection>;
-}>;
-export declare function withPagination<E>(): SignalStoreFeature<EmptyFeatureResult, EmptyFeatureResult & {
-    state: PaginationServiceState<E>;
-    props: PaginationServiceSignals<E>;
-}>;
-export declare function gotoPage<E, Collection extends string>(page: number, options?: {
-    collection: Collection;
-}): Partial<SetPaginationState<E, Collection>>;
-export declare function setPageSize<E, Collection extends string>(pageSize: number, options?: {
-    collection: Collection;
-}): Partial<SetPaginationState<E, Collection>>;
-export declare function nextPage<E, Collection extends string>(options?: {
-    collection: Collection;
-}): Partial<SetPaginationState<E, Collection>>;
-export declare function previousPage<E, Collection extends string>(options?: {
-    collection: Collection;
-}): Partial<SetPaginationState<E, Collection>>;
-export declare function firstPage<E, Collection extends string>(options?: {
-    collection: Collection;
-}): Partial<SetPaginationState<E, Collection>>;
-export declare function setMaxPageNavigationArrayItems<E, Collection extends string>(maxPageNavigationArrayItems: number, options?: {
-    collection: Collection;
-}): Partial<SetPaginationState<E, Collection>>;
-export declare function createPageArray(currentPage: number, itemsPerPage: number, totalItems: number, paginationRange: number): Page[];

package/lib/with-redux.d.ts

@@ -1,147 +0,0 @@
-import { EmptyFeatureResult, SignalStoreFeature, SignalStoreFeatureResult, WritableStateSource } from '@ngrx/signals';
-import { Observable } from 'rxjs';
-/** Actions **/
-type Payload = Record<string, unknown>;
-type ActionFn<Type extends string = string, ActionPayload extends Payload = Payload> = ((payload: ActionPayload) => ActionPayload & {
-    type: Type;
-}) & {
-    type: Type;
-};
-type ActionFns = Record<string, ActionFn>;
-export type ActionsFnSpecs = Record<string, Payload>;
-type ActionFnCreator<Spec extends ActionsFnSpecs> = {
-    [ActionName in keyof Spec]: (Record<never, never> extends Spec[ActionName] ? () => Spec[ActionName] & {
-        type: ActionName;
-    } : (payload: Spec[ActionName]) => Spec[ActionName] & {
-        type: ActionName;
-    }) & {
-        type: ActionName & string;
-    };
-};
-type ActionFnPayload<Action> = Action extends (payload: infer Payload) => void ? Payload : never;
-type ActionFnsCreator<Spec extends ActionsFnSpecs> = Spec extends {
-    private: Record<string, Payload>;
-    public: Record<string, Payload>;
-} ? ActionFnCreator<Spec['private']> & ActionFnCreator<Spec['public']> : ActionFnCreator<Spec>;
-type PublicActionFns<Spec extends ActionsFnSpecs> = Spec extends {
-    public: Record<string, Payload>;
-} ? ActionFnCreator<Spec['public']> : ActionFnCreator<Spec>;
-export declare function payload<Type extends Payload>(): Type;
-export declare const noPayload: {};
-/** Reducer **/
-type ReducerFunction<ReducerAction, State> = (state: State, action: ActionFnPayload<ReducerAction>) => void;
-type ReducerFactory<StateActionFns extends ActionFns, State> = (actions: StateActionFns, on: <ReducerAction extends {
-    type: string;
-}>(action: ReducerAction, reducerFn: ReducerFunction<ReducerAction, State>) => void) => void;
-/**
- * Creates a reducer function to separate the reducer logic into another file.
- *
- * ```typescript
- * interface FlightState {
- *   flights: Flight[];
- *   effect1: boolean;
- *   effect2: boolean;
- * }
- *
- * const initialState: FlightState = {
- *   flights: [],
- *   effect1: false,
- *   effect2: false,
- * };
- *
- * const actions = {
- *   init: noPayload,
- *   updateEffect1: payload<{ value: boolean }>(),
- *   updateEffect2: payload<{ value: boolean }>(),
- * };
- *
- * const reducer = createReducer<FlightState, typeof actions>((actions, on) => {
- *   on(actions.updateEffect1, (state, { value }) => {
- *     patchState(state, { effect1: value });
- *   });
- *
- *   on(actions.updateEffect2, (state, { value }) => {
- *     patchState(state, { effect2: value });
- *   });
- * });
- *
- * signalStore(
- *   withState(initialState),
- *   withRedux({
- *     actions,
- *     reducer,
- *   })
- * );
- * ```
- * @param reducerFactory
- */
-export declare function createReducer<State extends object, Actions extends ActionsFnSpecs>(reducerFactory: ReducerFactory<ActionFnsCreator<Actions>, WritableStateSource<State>>): ReducerFactory<ActionFnsCreator<Actions>, WritableStateSource<State>>;
-/** Effect **/
-type EffectsFactory<StateActionFns extends ActionFns> = (actions: StateActionFns, create: <EffectAction extends {
-    type: string;
-}>(action: EffectAction) => Observable<ActionFnPayload<EffectAction>>) => Record<string, Observable<unknown>>;
-/**
- * @deprecated Use NgRx's `@ngrx/signals/events` starting in 19.2
- *
- * Creates the effects function to separate the effects logic into another file.
- *
- * ```typescript
- * interface FlightState {
- *   flights: Flight[];
- *   effect1: boolean;
- *   effect2: boolean;
- * }
- *
- * const initialState: FlightState = {
- *   flights: [],
- *   effect1: false,
- *   effect2: false,
- * };
- *
- * const actions = {
- *   init: noPayload,
- *   updateEffect1: payload<{ value: boolean }>(),
- *   updateEffect2: payload<{ value: boolean }>(),
- * };
- *
- * const effects = createEffects(actions, (actions, create) => {
- *   return {
- *     init1$: create(actions.init).pipe(
- *       map(() => actions.updateEffect1({ value: true }))
- *     ),
- *     init2$: create(actions.init).pipe(
- *       map(() => actions.updateEffect2({ value: true }))
- *     ),
- *   };
- * });
- *
- * signalStore(
- *   withState(initialState),
- *   withRedux({
- *     actions,
- *     effects,
- *   })
- * );
- * ```
- * @param actions
- * @param effectsFactory
- */
-export declare function createEffects<Actions extends ActionsFnSpecs>(actions: Actions, effectsFactory: EffectsFactory<ActionFnsCreator<Actions>>): EffectsFactory<ActionFnsCreator<Actions>>;
-/**
- * @param redux redux
- *
- * properties do not start with `with` since they are not extension functions on their own.
- *
- * no dependency to NgRx
- *
- * actions are passed to reducer and effects, but it is also possible to use other actions.
- * effects provide forAction and do not return anything. that is important because effects should stay inaccessible
- */
-export declare function withRedux<Spec extends ActionsFnSpecs, Input extends SignalStoreFeatureResult, StateActionFns extends ActionFnsCreator<Spec> = ActionFnsCreator<Spec>, PublicStoreActionFns extends PublicActionFns<Spec> = PublicActionFns<Spec>>(redux: {
-    actions: Spec;
-    reducer: ReducerFactory<StateActionFns, WritableStateSource<Input['state']>>;
-    effects: EffectsFactory<StateActionFns>;
-}): SignalStoreFeature<Input, EmptyFeatureResult & {
-    methods: PublicStoreActionFns;
-}>;
-export {};

package/lib/with-reset.d.ts

@@ -1,29 +0,0 @@
-import { StateSource } from '@ngrx/signals';
-export type PublicMethods = {
-    resetState(): void;
-};
-/**
- * Adds a `resetState` method to the store, which resets the state
- * to the initial state.
- *
- * If you want to set a custom initial state, you can use {@link setResetState}.
- */
-export declare function withReset(): import("@ngrx/signals").SignalStoreFeature<import("@ngrx/signals").EmptyFeatureResult, {
-    state: {};
-    props: {
-        _resetState: {
-            value: {};
-        };
-    };
-    methods: {
-        resetState: () => void;
-    };
-}>;
-/**
- * Sets the reset state of the store to the given state.
- *
- * Throws an error if the store is not configured with {@link withReset}.
- * @param store the instance of a SignalStore
- * @param state the state to set as the reset state
- */
-export declare function setResetState<State extends object>(store: StateSource<State>, state: State): void;

package/lib/with-undo-redo.d.ts

@@ -1,31 +0,0 @@
-import { Signal } from '@angular/core';
-import { EmptyFeatureResult, SignalStoreFeature, SignalStoreFeatureResult } from '@ngrx/signals';
-export type StackItem = Record<string, unknown>;
-export type NormalizedUndoRedoOptions = {
-    maxStackSize: number;
-    collections?: string[];
-    keys: string[];
-    skip: number;
-};
-export declare function getUndoRedoKeys(collections?: string[]): string[];
-type NonNever<T> = T extends never ? never : T;
-type ExtractEntityCollection<T> = T extends `${infer U}Entities` ? U : never;
-type ExtractEntityCollections<Store extends SignalStoreFeatureResult> = NonNever<{
-    [K in keyof Store['props']]: ExtractEntityCollection<K>;
-}[keyof Store['props']]>;
-type OptionsForState<Store extends SignalStoreFeatureResult> = Partial<Omit<NormalizedUndoRedoOptions, 'collections' | 'keys'>> & {
-    collections?: ExtractEntityCollections<Store>[];
-    keys?: (keyof Store['state'])[];
-};
-export declare function withUndoRedo<Input extends EmptyFeatureResult>(options?: OptionsForState<Input>): SignalStoreFeature<Input, EmptyFeatureResult & {
-    props: {
-        canUndo: Signal<boolean>;
-        canRedo: Signal<boolean>;
-    };
-    methods: {
-        undo: () => void;
-        redo: () => void;
-        clearStack: () => void;
-    };
-}>;
-export {};

package/redux-connector/src/lib/create-redux.d.ts

@@ -1,13 +0,0 @@
-import { ActionCreator, ActionType } from '@ngrx/store/src/models';
-import { CreateReduxState, MapperTypes, Store } from './model';
-export declare function mapAction<Creators extends readonly ActionCreator[]>(...args: [
-    ...creators: Creators,
-    storeMethod: (action: ActionType<Creators[number]>) => unknown
-]): MapperTypes<Creators>;
-export declare function mapAction<Creators extends readonly ActionCreator[], T>(...args: [
-    ...creators: Creators,
-    storeMethod: (action: ActionType<Creators[number]>, resultMethod: (input: T) => unknown) => unknown,
-    resultMethod: (input: T) => unknown
-]): MapperTypes<Creators>;
-export declare function withActionMappers(...mappers: MapperTypes<ActionCreator[]>[]): MapperTypes<ActionCreator[]>[];
-export declare function createReduxState<StoreName extends string, STORE extends Store>(storeName: StoreName, signalStore: STORE, withActionMappers: (store: InstanceType<STORE>) => MapperTypes<ActionCreator[]>[]): CreateReduxState<StoreName, STORE>;

package/redux-connector/src/lib/model.d.ts

@@ -1,40 +0,0 @@
-import { EnvironmentProviders, Signal, Type } from '@angular/core';
-import { DeepSignal } from '@ngrx/signals/src/deep-signal';
-import { SignalStoreFeatureResult, StateSignals } from '@ngrx/signals/src/signal-store-models';
-import { Action, ActionCreator, ActionType, Prettify } from '@ngrx/store/src/models';
-import { Observable, Unsubscribable } from 'rxjs';
-export type IncludePropType<T, V, WithNevers = {
-    [K in keyof T]: Exclude<T[K], undefined> extends V ? T[K] extends Record<string, unknown> ? IncludePropType<T[K], V> : T[K] : never;
-}> = Prettify<Pick<WithNevers, {
-    [K in keyof WithNevers]: WithNevers[K] extends never ? never : K extends string ? K : never;
-}[keyof WithNevers]>>;
-export type Store = Type<Record<string, unknown> & StateSignals<SignalStoreFeatureResult['state']>>;
-export type CreateReduxState<StoreName extends string, STORE extends Store> = {
-    [K in StoreName as `provide${Capitalize<K>}Store`]: (connectReduxDevtools?: boolean) => EnvironmentProviders;
-} & {
-    [K in StoreName as `inject${Capitalize<K>}Store`]: () => InjectableReduxSlice<STORE>;
-};
-export type Selectors<STORE extends Store> = IncludePropType<InstanceType<STORE>, Signal<unknown> | DeepSignal<unknown>>;
-export type Dispatch = {
-    dispatch: (input: Action | Observable<Action> | Signal<Action>) => Unsubscribable;
-};
-export type InjectableReduxSlice<STORE extends Store> = Selectors<STORE> & Dispatch;
-export type ExtractActionTypes<Creators extends readonly ActionCreator[]> = {
-    [Key in keyof Creators]: Creators[Key] extends ActionCreator<infer T> ? T : never;
-};
-export interface ActionMethod<T, V extends Action = Action> {
-    (action: V): T;
-}
-export interface StoreMethod<Creators extends readonly ActionCreator[], ResultState = unknown> {
-    (action: ActionType<Creators[number]>): ResultState;
-}
-export interface MapperTypes<Creators extends readonly ActionCreator[]> {
-    types: ExtractActionTypes<Creators>;
-    storeMethod: StoreMethod<Creators>;
-    resultMethod?: (...args: unknown[]) => unknown;
-}
-export type ServiceWithDecorator = {
-    ɵprov?: {
-        providedIn?: string;
-    };
-};

package/redux-connector/src/lib/rxjs-interop/redux-method.d.ts

@@ -1,14 +0,0 @@
-import { Injector, Signal } from '@angular/core';
-import { Observable } from 'rxjs';
-type RxMethodInput<Input> = Input | Observable<Input> | Signal<Input>;
-type RxMethodRef = {
-    destroy: () => void;
-};
-type RxMethod<Input, MethodInput = Input, MethodResult = unknown> = ((input: RxMethodInput<Input>, resultMethod: (input: MethodInput) => MethodResult) => RxMethodRef) & RxMethodRef;
-export declare function reduxMethod<Input, MethodInput = Input>(generator: (source$: Observable<Input>) => Observable<MethodInput>, config?: {
-    injector?: Injector;
-}): RxMethod<Input, MethodInput>;
-export declare function reduxMethod<Input, MethodInput = Input, MethodResult = unknown>(generator: (source$: Observable<Input>) => Observable<MethodInput>, resultMethod: (input: MethodInput) => MethodResult, config?: {
-    injector?: Injector;
-}): RxMethod<Input, MethodInput, MethodResult>;
-export {};

package/redux-connector/src/lib/signal-redux-store.d.ts

@@ -1,11 +0,0 @@
-import { Action, ActionCreator } from '@ngrx/store';
-import { MapperTypes } from './model';
-import * as i0 from "@angular/core";
-export declare class SignalReduxStore {
-    private mapperDict;
-    dispatch: import("@ngrx/signals/rxjs-interop").RxMethod<Action<string>>;
-    connectFeatureStore(mappers: MapperTypes<ActionCreator<any, any>[]>[]): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SignalReduxStore, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<SignalReduxStore>;
-}
-export declare function injectReduxDispatch(): import("@ngrx/signals/rxjs-interop").RxMethod<Action<string>>;

package/redux-connector/src/lib/util.d.ts

@@ -1,5 +0,0 @@
-import { ActionCreator } from '@ngrx/store';
-import { Unsubscribable } from 'rxjs';
-export declare function isUnsubscribable<F extends (...args: unknown[]) => unknown>(fn: F | (F & Unsubscribable)): fn is F & Unsubscribable;
-export declare function capitalize(str: string): string;
-export declare function isActionCreator(action: unknown): action is ActionCreator;