import { ActionCreator, Creator, MemoizedSelector } from '@ngrx/store';
import type { OnReducer } from '@ngrx/store/src/reducer_creator';
import { RefreshParams, RefreshResult } from '@sowatech/shared/ds-datasource';
export interface ExternalRefreshState<T> {
    refreshResult: RefreshResult<T> | null;
    loading: boolean;
}
type Id = any;
export declare class ExternalRefreshAdapter<T> {
    /**
     * Initial State für external Refresh.
     * ```ts
     * type State = ExternalRefreshState<MyEntity> & { loading: boolean };
     * const initialState: State = adapter.getInitialState({ loading: false });
     * ```
     * @param extraState zusätzlicher State, der neben dem `refreshResult` abgelegt wird
     */
    getInitialState<ExtraState>(extraState?: ExtraState): ExternalRefreshState<T> & ExtraState;
    /**
     * Zum Updaten des Refresh Results
     * ```ts
     * on(apiActions.loadSuccess, (state, { refreshResult }) => adapter.update(refreshResult, state)),
     * ```
     */
    update<State extends ExternalRefreshState<T>>(result: RefreshResult<T>, state: State): State;
    /**
     * Zum Updaten des Refresh Results über `externalRefreshProps`
     * ```ts
     * // Action
     * 'Load Success': externalRefreshProps<MyEntity>(),
     * // Reducer
     * on(apiActions.loadSuccess, adapter.updateFromAction()),
     * ```
     */
    updateFromAction<State extends ExternalRefreshState<T>>(): OnReducer<State, ExternalRefreshResultAction<T>[]>;
    /**
     * Löscht das Refresh Result
     */
    clear<State extends ExternalRefreshState<T>>(state: State): State;
    setLoading<State extends ExternalRefreshState<T>>(loading: boolean, state: State): State & {
        loading: boolean;
    };
    /**
     * Zum Setzen von `loading`
     * ```ts
     * on(apiActions.loadSuccess, apiAction.loadFailure, adapter.setLoadingStatic(false)),
     * ```
     */
    setLoadingStatic<State extends ExternalRefreshState<T>>(loading: boolean): (state: State) => State & {
        loading: boolean;
    };
    /**
     * Setzt Loading auf `true`, wenn nicht nur für die Aggregate Params neu geladen wird.
     * ```ts
     * on(apiActions.load, (state, { refreshParams }) => adapter.startLoading(refreshParams, state)),
     * ```
     */
    startLoading<State extends ExternalRefreshState<T>>(refreshParams: RefreshParams, state: State): State;
    /**
     * Gibt ein paar nützliche Selectors zurück:
     */
    getSelectors(): {
        selectList: (state: ExternalRefreshState<T>) => T[];
        selectItem: (state: ExternalRefreshState<T>, id: Id) => T;
        selectIds: (state: ExternalRefreshState<T>) => Id[];
    };
    /**
     * Da der Store immutable ist, muss der Selector für die Datasource überschrieben werden.
     * (SHANG-465)
     */
    createRefreshResultSelector(selector: MemoizedSelector<ExternalRefreshState<T>, RefreshResult<T> | null>): MemoizedSelector<ExternalRefreshState<T>, any, (s1: RefreshResult<T>) => any>;
}
/**
 * Erstellt einen Adapter für den Umgang mit serverseitig geladenen Collections.
 * ```ts
 * const adapter = createExternalRefreshAdapter<MyEntity>();
 *
 * type State = ExternalRefreshState<MyEntity>;
 *
 * const initialState: State = adapter.getInitialState();
 *
 * const myFeature = createFeature({
 *     name: 'myFeature',
 *     reducer: createReducer(
 *         initialState,
 *         on(apiActions.loadSuccess, adapter.updateFromAction()),
 *         on(actions.load, (state, { refreshParams }) => adapter.startLoading(refreshParams, state)),
 *         on(apiActions.loadSuccess, apiActions.loadFailure, adapter.setLoadingStatic(false)),
 *     ),
 *     extraSelectors(baseSelectors) {
 *         const selectRefreshResult = adapter.createRefreshResultSelector(baseSelectors.selectRefreshResult);
 *         return {
 *             selectRefreshResult,
 *         };
 *     },
 * });
 *
 * // Load Action
 * 'Load': externalRefreshParamsProps(),
 * // API Action
 * 'Load Success': externalRefreshResultProps<MyEntity>(),
 * ```
 */
export declare function createExternalRefreshAdapter<T>(): ExternalRefreshAdapter<T>;
export type ExternalRefreshResultProps<T> = {
    refreshResult: RefreshResult<T>;
};
export type ExternalRefreshResultAction<T> = ActionCreator<string, Creator<[RefreshResult<T>], ExternalRefreshResultProps<T> & {
    type: string;
}>>;
export declare function externalRefreshResultProps<T>(): (refreshResult: RefreshResult<T>) => ExternalRefreshResultProps<T>;
export type ExternalRefreshParamsProps = {
    refreshParams: RefreshParams;
};
export type ExternalRefreshParamsAction<Type extends string = string> = ActionCreator<Type, Creator<[RefreshParams], ExternalRefreshParamsProps & {
    type: Type;
}>>;
export declare function externalRefreshParamsProps(): (refreshParams: RefreshParams) => ExternalRefreshParamsProps;
export {};